github.com/Onther-Tech/plasma-evm@v0.0.0-rc7.7/contracts/plasma/ethertoken/ethertoken.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 ethertoken 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 // BasicTokenABI is the input ABI used to generate the binding from. 31 const BasicTokenABI = "[{\"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\"}],\"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\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 32 33 // BasicTokenFuncSigs maps the 4-byte function signature to its string representation. 34 var BasicTokenFuncSigs = map[string]string{ 35 "70a08231": "balanceOf(address)", 36 "18160ddd": "totalSupply()", 37 "a9059cbb": "transfer(address,uint256)", 38 } 39 40 // BasicTokenBin is the compiled bytecode used for deploying new contracts. 41 var BasicTokenBin = "0x608060405234801561001057600080fd5b5061021e806100206000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c806318160ddd1461004657806370a0823114610060578063a9059cbb14610086575b600080fd5b61004e6100c6565b60408051918252519081900360200190f35b61004e6004803603602081101561007657600080fd5b50356001600160a01b03166100cc565b6100b26004803603604081101561009c57600080fd5b506001600160a01b0381351690602001356100e7565b604080519115158252519081900360200190f35b60015490565b6001600160a01b031660009081526020819052604090205490565b3360009081526020819052604081205482111561010357600080fd5b6001600160a01b03831661011657600080fd5b33600090815260208190526040902054610136908363ffffffff6101c416565b33600090815260208190526040808220929092556001600160a01b03851681522054610168908363ffffffff6101d616565b6001600160a01b038416600081815260208181526040918290209390935580518581529051919233927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9281900390910190a350600192915050565b6000828211156101d057fe5b50900390565b818101828110156101e357fe5b9291505056fea265627a7a723158205e9d3efb11f85116fe1b413347ffe44c247462ae21aeec744b6a7a5bba4a269b64736f6c634300050c0032" 42 43 // DeployBasicToken deploys a new Ethereum contract, binding an instance of BasicToken to it. 44 func DeployBasicToken(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *BasicToken, error) { 45 parsed, err := abi.JSON(strings.NewReader(BasicTokenABI)) 46 if err != nil { 47 return common.Address{}, nil, nil, err 48 } 49 50 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(BasicTokenBin), backend) 51 if err != nil { 52 return common.Address{}, nil, nil, err 53 } 54 return address, tx, &BasicToken{BasicTokenCaller: BasicTokenCaller{contract: contract}, BasicTokenTransactor: BasicTokenTransactor{contract: contract}, BasicTokenFilterer: BasicTokenFilterer{contract: contract}}, nil 55 } 56 57 // BasicToken is an auto generated Go binding around an Ethereum contract. 58 type BasicToken struct { 59 BasicTokenCaller // Read-only binding to the contract 60 BasicTokenTransactor // Write-only binding to the contract 61 BasicTokenFilterer // Log filterer for contract events 62 } 63 64 // BasicTokenCaller is an auto generated read-only Go binding around an Ethereum contract. 65 type BasicTokenCaller struct { 66 contract *bind.BoundContract // Generic contract wrapper for the low level calls 67 } 68 69 // BasicTokenTransactor is an auto generated write-only Go binding around an Ethereum contract. 70 type BasicTokenTransactor struct { 71 contract *bind.BoundContract // Generic contract wrapper for the low level calls 72 } 73 74 // BasicTokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 75 type BasicTokenFilterer struct { 76 contract *bind.BoundContract // Generic contract wrapper for the low level calls 77 } 78 79 // BasicTokenSession is an auto generated Go binding around an Ethereum contract, 80 // with pre-set call and transact options. 81 type BasicTokenSession struct { 82 Contract *BasicToken // Generic contract binding to set the session for 83 CallOpts bind.CallOpts // Call options to use throughout this session 84 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 85 } 86 87 // BasicTokenCallerSession is an auto generated read-only Go binding around an Ethereum contract, 88 // with pre-set call options. 89 type BasicTokenCallerSession struct { 90 Contract *BasicTokenCaller // Generic contract caller binding to set the session for 91 CallOpts bind.CallOpts // Call options to use throughout this session 92 } 93 94 // BasicTokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 95 // with pre-set transact options. 96 type BasicTokenTransactorSession struct { 97 Contract *BasicTokenTransactor // Generic contract transactor binding to set the session for 98 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 99 } 100 101 // BasicTokenRaw is an auto generated low-level Go binding around an Ethereum contract. 102 type BasicTokenRaw struct { 103 Contract *BasicToken // Generic contract binding to access the raw methods on 104 } 105 106 // BasicTokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 107 type BasicTokenCallerRaw struct { 108 Contract *BasicTokenCaller // Generic read-only contract binding to access the raw methods on 109 } 110 111 // BasicTokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 112 type BasicTokenTransactorRaw struct { 113 Contract *BasicTokenTransactor // Generic write-only contract binding to access the raw methods on 114 } 115 116 // NewBasicToken creates a new instance of BasicToken, bound to a specific deployed contract. 117 func NewBasicToken(address common.Address, backend bind.ContractBackend) (*BasicToken, error) { 118 contract, err := bindBasicToken(address, backend, backend, backend) 119 if err != nil { 120 return nil, err 121 } 122 return &BasicToken{BasicTokenCaller: BasicTokenCaller{contract: contract}, BasicTokenTransactor: BasicTokenTransactor{contract: contract}, BasicTokenFilterer: BasicTokenFilterer{contract: contract}}, nil 123 } 124 125 // NewBasicTokenCaller creates a new read-only instance of BasicToken, bound to a specific deployed contract. 126 func NewBasicTokenCaller(address common.Address, caller bind.ContractCaller) (*BasicTokenCaller, error) { 127 contract, err := bindBasicToken(address, caller, nil, nil) 128 if err != nil { 129 return nil, err 130 } 131 return &BasicTokenCaller{contract: contract}, nil 132 } 133 134 // NewBasicTokenTransactor creates a new write-only instance of BasicToken, bound to a specific deployed contract. 135 func NewBasicTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*BasicTokenTransactor, error) { 136 contract, err := bindBasicToken(address, nil, transactor, nil) 137 if err != nil { 138 return nil, err 139 } 140 return &BasicTokenTransactor{contract: contract}, nil 141 } 142 143 // NewBasicTokenFilterer creates a new log filterer instance of BasicToken, bound to a specific deployed contract. 144 func NewBasicTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*BasicTokenFilterer, error) { 145 contract, err := bindBasicToken(address, nil, nil, filterer) 146 if err != nil { 147 return nil, err 148 } 149 return &BasicTokenFilterer{contract: contract}, nil 150 } 151 152 // bindBasicToken binds a generic wrapper to an already deployed contract. 153 func bindBasicToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 154 parsed, err := abi.JSON(strings.NewReader(BasicTokenABI)) 155 if err != nil { 156 return nil, err 157 } 158 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 159 } 160 161 // Call invokes the (constant) contract method with params as input values and 162 // sets the output to result. The result type might be a single field for simple 163 // returns, a slice of interfaces for anonymous returns and a struct for named 164 // returns. 165 func (_BasicToken *BasicTokenRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 166 return _BasicToken.Contract.BasicTokenCaller.contract.Call(opts, result, method, params...) 167 } 168 169 // Transfer initiates a plain transaction to move funds to the contract, calling 170 // its default method if one is available. 171 func (_BasicToken *BasicTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 172 return _BasicToken.Contract.BasicTokenTransactor.contract.Transfer(opts) 173 } 174 175 // Transact invokes the (paid) contract method with params as input values. 176 func (_BasicToken *BasicTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 177 return _BasicToken.Contract.BasicTokenTransactor.contract.Transact(opts, method, params...) 178 } 179 180 // Call invokes the (constant) contract method with params as input values and 181 // sets the output to result. The result type might be a single field for simple 182 // returns, a slice of interfaces for anonymous returns and a struct for named 183 // returns. 184 func (_BasicToken *BasicTokenCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 185 return _BasicToken.Contract.contract.Call(opts, result, method, params...) 186 } 187 188 // Transfer initiates a plain transaction to move funds to the contract, calling 189 // its default method if one is available. 190 func (_BasicToken *BasicTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 191 return _BasicToken.Contract.contract.Transfer(opts) 192 } 193 194 // Transact invokes the (paid) contract method with params as input values. 195 func (_BasicToken *BasicTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 196 return _BasicToken.Contract.contract.Transact(opts, method, params...) 197 } 198 199 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 200 // 201 // Solidity: function balanceOf(address _owner) constant returns(uint256) 202 func (_BasicToken *BasicTokenCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) { 203 var ( 204 ret0 = new(*big.Int) 205 ) 206 out := ret0 207 err := _BasicToken.contract.Call(opts, out, "balanceOf", _owner) 208 return *ret0, err 209 } 210 211 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 212 // 213 // Solidity: function balanceOf(address _owner) constant returns(uint256) 214 func (_BasicToken *BasicTokenSession) BalanceOf(_owner common.Address) (*big.Int, error) { 215 return _BasicToken.Contract.BalanceOf(&_BasicToken.CallOpts, _owner) 216 } 217 218 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 219 // 220 // Solidity: function balanceOf(address _owner) constant returns(uint256) 221 func (_BasicToken *BasicTokenCallerSession) BalanceOf(_owner common.Address) (*big.Int, error) { 222 return _BasicToken.Contract.BalanceOf(&_BasicToken.CallOpts, _owner) 223 } 224 225 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 226 // 227 // Solidity: function totalSupply() constant returns(uint256) 228 func (_BasicToken *BasicTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 229 var ( 230 ret0 = new(*big.Int) 231 ) 232 out := ret0 233 err := _BasicToken.contract.Call(opts, out, "totalSupply") 234 return *ret0, err 235 } 236 237 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 238 // 239 // Solidity: function totalSupply() constant returns(uint256) 240 func (_BasicToken *BasicTokenSession) TotalSupply() (*big.Int, error) { 241 return _BasicToken.Contract.TotalSupply(&_BasicToken.CallOpts) 242 } 243 244 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 245 // 246 // Solidity: function totalSupply() constant returns(uint256) 247 func (_BasicToken *BasicTokenCallerSession) TotalSupply() (*big.Int, error) { 248 return _BasicToken.Contract.TotalSupply(&_BasicToken.CallOpts) 249 } 250 251 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 252 // 253 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 254 func (_BasicToken *BasicTokenTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error) { 255 return _BasicToken.contract.Transact(opts, "transfer", _to, _value) 256 } 257 258 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 259 // 260 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 261 func (_BasicToken *BasicTokenSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { 262 return _BasicToken.Contract.Transfer(&_BasicToken.TransactOpts, _to, _value) 263 } 264 265 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 266 // 267 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 268 func (_BasicToken *BasicTokenTransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { 269 return _BasicToken.Contract.Transfer(&_BasicToken.TransactOpts, _to, _value) 270 } 271 272 // BasicTokenTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the BasicToken contract. 273 type BasicTokenTransferIterator struct { 274 Event *BasicTokenTransfer // Event containing the contract specifics and raw log 275 276 contract *bind.BoundContract // Generic contract to use for unpacking event data 277 event string // Event name to use for unpacking event data 278 279 logs chan types.Log // Log channel receiving the found contract events 280 sub ethereum.Subscription // Subscription for errors, completion and termination 281 done bool // Whether the subscription completed delivering logs 282 fail error // Occurred error to stop iteration 283 } 284 285 // Next advances the iterator to the subsequent event, returning whether there 286 // are any more events found. In case of a retrieval or parsing error, false is 287 // returned and Error() can be queried for the exact failure. 288 func (it *BasicTokenTransferIterator) Next() bool { 289 // If the iterator failed, stop iterating 290 if it.fail != nil { 291 return false 292 } 293 // If the iterator completed, deliver directly whatever's available 294 if it.done { 295 select { 296 case log := <-it.logs: 297 it.Event = new(BasicTokenTransfer) 298 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 299 it.fail = err 300 return false 301 } 302 it.Event.Raw = log 303 return true 304 305 default: 306 return false 307 } 308 } 309 // Iterator still in progress, wait for either a data or an error event 310 select { 311 case log := <-it.logs: 312 it.Event = new(BasicTokenTransfer) 313 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 314 it.fail = err 315 return false 316 } 317 it.Event.Raw = log 318 return true 319 320 case err := <-it.sub.Err(): 321 it.done = true 322 it.fail = err 323 return it.Next() 324 } 325 } 326 327 // Error returns any retrieval or parsing error occurred during filtering. 328 func (it *BasicTokenTransferIterator) Error() error { 329 return it.fail 330 } 331 332 // Close terminates the iteration process, releasing any pending underlying 333 // resources. 334 func (it *BasicTokenTransferIterator) Close() error { 335 it.sub.Unsubscribe() 336 return nil 337 } 338 339 // BasicTokenTransfer represents a Transfer event raised by the BasicToken contract. 340 type BasicTokenTransfer struct { 341 From common.Address 342 To common.Address 343 Value *big.Int 344 Raw types.Log // Blockchain specific contextual infos 345 } 346 347 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 348 // 349 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 350 func (_BasicToken *BasicTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*BasicTokenTransferIterator, error) { 351 352 var fromRule []interface{} 353 for _, fromItem := range from { 354 fromRule = append(fromRule, fromItem) 355 } 356 var toRule []interface{} 357 for _, toItem := range to { 358 toRule = append(toRule, toItem) 359 } 360 361 logs, sub, err := _BasicToken.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 362 if err != nil { 363 return nil, err 364 } 365 return &BasicTokenTransferIterator{contract: _BasicToken.contract, event: "Transfer", logs: logs, sub: sub}, nil 366 } 367 368 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 369 // 370 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 371 func (_BasicToken *BasicTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *BasicTokenTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 372 373 var fromRule []interface{} 374 for _, fromItem := range from { 375 fromRule = append(fromRule, fromItem) 376 } 377 var toRule []interface{} 378 for _, toItem := range to { 379 toRule = append(toRule, toItem) 380 } 381 382 logs, sub, err := _BasicToken.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 383 if err != nil { 384 return nil, err 385 } 386 return event.NewSubscription(func(quit <-chan struct{}) error { 387 defer sub.Unsubscribe() 388 for { 389 select { 390 case log := <-logs: 391 // New log arrived, parse the event and forward to the user 392 event := new(BasicTokenTransfer) 393 if err := _BasicToken.contract.UnpackLog(event, "Transfer", log); err != nil { 394 return err 395 } 396 event.Raw = log 397 398 select { 399 case sink <- event: 400 case err := <-sub.Err(): 401 return err 402 case <-quit: 403 return nil 404 } 405 case err := <-sub.Err(): 406 return err 407 case <-quit: 408 return nil 409 } 410 } 411 }), nil 412 } 413 414 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 415 // 416 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 417 func (_BasicToken *BasicTokenFilterer) ParseTransfer(log types.Log) (*BasicTokenTransfer, error) { 418 event := new(BasicTokenTransfer) 419 if err := _BasicToken.contract.UnpackLog(event, "Transfer", log); err != nil { 420 return nil, err 421 } 422 return event, nil 423 } 424 425 // ERC20ABI is the input ABI used to generate the binding from. 426 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\":\"_value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_who\",\"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\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 427 428 // ERC20FuncSigs maps the 4-byte function signature to its string representation. 429 var ERC20FuncSigs = map[string]string{ 430 "dd62ed3e": "allowance(address,address)", 431 "095ea7b3": "approve(address,uint256)", 432 "70a08231": "balanceOf(address)", 433 "18160ddd": "totalSupply()", 434 "a9059cbb": "transfer(address,uint256)", 435 "23b872dd": "transferFrom(address,address,uint256)", 436 } 437 438 // ERC20 is an auto generated Go binding around an Ethereum contract. 439 type ERC20 struct { 440 ERC20Caller // Read-only binding to the contract 441 ERC20Transactor // Write-only binding to the contract 442 ERC20Filterer // Log filterer for contract events 443 } 444 445 // ERC20Caller is an auto generated read-only Go binding around an Ethereum contract. 446 type ERC20Caller struct { 447 contract *bind.BoundContract // Generic contract wrapper for the low level calls 448 } 449 450 // ERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. 451 type ERC20Transactor struct { 452 contract *bind.BoundContract // Generic contract wrapper for the low level calls 453 } 454 455 // ERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. 456 type ERC20Filterer struct { 457 contract *bind.BoundContract // Generic contract wrapper for the low level calls 458 } 459 460 // ERC20Session is an auto generated Go binding around an Ethereum contract, 461 // with pre-set call and transact options. 462 type ERC20Session struct { 463 Contract *ERC20 // Generic contract binding to set the session for 464 CallOpts bind.CallOpts // Call options to use throughout this session 465 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 466 } 467 468 // ERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, 469 // with pre-set call options. 470 type ERC20CallerSession struct { 471 Contract *ERC20Caller // Generic contract caller binding to set the session for 472 CallOpts bind.CallOpts // Call options to use throughout this session 473 } 474 475 // ERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, 476 // with pre-set transact options. 477 type ERC20TransactorSession struct { 478 Contract *ERC20Transactor // Generic contract transactor binding to set the session for 479 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 480 } 481 482 // ERC20Raw is an auto generated low-level Go binding around an Ethereum contract. 483 type ERC20Raw struct { 484 Contract *ERC20 // Generic contract binding to access the raw methods on 485 } 486 487 // ERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 488 type ERC20CallerRaw struct { 489 Contract *ERC20Caller // Generic read-only contract binding to access the raw methods on 490 } 491 492 // ERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 493 type ERC20TransactorRaw struct { 494 Contract *ERC20Transactor // Generic write-only contract binding to access the raw methods on 495 } 496 497 // NewERC20 creates a new instance of ERC20, bound to a specific deployed contract. 498 func NewERC20(address common.Address, backend bind.ContractBackend) (*ERC20, error) { 499 contract, err := bindERC20(address, backend, backend, backend) 500 if err != nil { 501 return nil, err 502 } 503 return &ERC20{ERC20Caller: ERC20Caller{contract: contract}, ERC20Transactor: ERC20Transactor{contract: contract}, ERC20Filterer: ERC20Filterer{contract: contract}}, nil 504 } 505 506 // NewERC20Caller creates a new read-only instance of ERC20, bound to a specific deployed contract. 507 func NewERC20Caller(address common.Address, caller bind.ContractCaller) (*ERC20Caller, error) { 508 contract, err := bindERC20(address, caller, nil, nil) 509 if err != nil { 510 return nil, err 511 } 512 return &ERC20Caller{contract: contract}, nil 513 } 514 515 // NewERC20Transactor creates a new write-only instance of ERC20, bound to a specific deployed contract. 516 func NewERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC20Transactor, error) { 517 contract, err := bindERC20(address, nil, transactor, nil) 518 if err != nil { 519 return nil, err 520 } 521 return &ERC20Transactor{contract: contract}, nil 522 } 523 524 // NewERC20Filterer creates a new log filterer instance of ERC20, bound to a specific deployed contract. 525 func NewERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC20Filterer, error) { 526 contract, err := bindERC20(address, nil, nil, filterer) 527 if err != nil { 528 return nil, err 529 } 530 return &ERC20Filterer{contract: contract}, nil 531 } 532 533 // bindERC20 binds a generic wrapper to an already deployed contract. 534 func bindERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 535 parsed, err := abi.JSON(strings.NewReader(ERC20ABI)) 536 if err != nil { 537 return nil, err 538 } 539 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 540 } 541 542 // Call invokes the (constant) contract method with params as input values and 543 // sets the output to result. The result type might be a single field for simple 544 // returns, a slice of interfaces for anonymous returns and a struct for named 545 // returns. 546 func (_ERC20 *ERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 547 return _ERC20.Contract.ERC20Caller.contract.Call(opts, result, method, params...) 548 } 549 550 // Transfer initiates a plain transaction to move funds to the contract, calling 551 // its default method if one is available. 552 func (_ERC20 *ERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 553 return _ERC20.Contract.ERC20Transactor.contract.Transfer(opts) 554 } 555 556 // Transact invokes the (paid) contract method with params as input values. 557 func (_ERC20 *ERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 558 return _ERC20.Contract.ERC20Transactor.contract.Transact(opts, method, params...) 559 } 560 561 // Call invokes the (constant) contract method with params as input values and 562 // sets the output to result. The result type might be a single field for simple 563 // returns, a slice of interfaces for anonymous returns and a struct for named 564 // returns. 565 func (_ERC20 *ERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 566 return _ERC20.Contract.contract.Call(opts, result, method, params...) 567 } 568 569 // Transfer initiates a plain transaction to move funds to the contract, calling 570 // its default method if one is available. 571 func (_ERC20 *ERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 572 return _ERC20.Contract.contract.Transfer(opts) 573 } 574 575 // Transact invokes the (paid) contract method with params as input values. 576 func (_ERC20 *ERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 577 return _ERC20.Contract.contract.Transact(opts, method, params...) 578 } 579 580 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 581 // 582 // Solidity: function allowance(address _owner, address _spender) constant returns(uint256) 583 func (_ERC20 *ERC20Caller) Allowance(opts *bind.CallOpts, _owner common.Address, _spender common.Address) (*big.Int, error) { 584 var ( 585 ret0 = new(*big.Int) 586 ) 587 out := ret0 588 err := _ERC20.contract.Call(opts, out, "allowance", _owner, _spender) 589 return *ret0, err 590 } 591 592 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 593 // 594 // Solidity: function allowance(address _owner, address _spender) constant returns(uint256) 595 func (_ERC20 *ERC20Session) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) { 596 return _ERC20.Contract.Allowance(&_ERC20.CallOpts, _owner, _spender) 597 } 598 599 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 600 // 601 // Solidity: function allowance(address _owner, address _spender) constant returns(uint256) 602 func (_ERC20 *ERC20CallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) { 603 return _ERC20.Contract.Allowance(&_ERC20.CallOpts, _owner, _spender) 604 } 605 606 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 607 // 608 // Solidity: function balanceOf(address _who) constant returns(uint256) 609 func (_ERC20 *ERC20Caller) BalanceOf(opts *bind.CallOpts, _who common.Address) (*big.Int, error) { 610 var ( 611 ret0 = new(*big.Int) 612 ) 613 out := ret0 614 err := _ERC20.contract.Call(opts, out, "balanceOf", _who) 615 return *ret0, err 616 } 617 618 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 619 // 620 // Solidity: function balanceOf(address _who) constant returns(uint256) 621 func (_ERC20 *ERC20Session) BalanceOf(_who common.Address) (*big.Int, error) { 622 return _ERC20.Contract.BalanceOf(&_ERC20.CallOpts, _who) 623 } 624 625 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 626 // 627 // Solidity: function balanceOf(address _who) constant returns(uint256) 628 func (_ERC20 *ERC20CallerSession) BalanceOf(_who common.Address) (*big.Int, error) { 629 return _ERC20.Contract.BalanceOf(&_ERC20.CallOpts, _who) 630 } 631 632 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 633 // 634 // Solidity: function totalSupply() constant returns(uint256) 635 func (_ERC20 *ERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 636 var ( 637 ret0 = new(*big.Int) 638 ) 639 out := ret0 640 err := _ERC20.contract.Call(opts, out, "totalSupply") 641 return *ret0, err 642 } 643 644 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 645 // 646 // Solidity: function totalSupply() constant returns(uint256) 647 func (_ERC20 *ERC20Session) TotalSupply() (*big.Int, error) { 648 return _ERC20.Contract.TotalSupply(&_ERC20.CallOpts) 649 } 650 651 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 652 // 653 // Solidity: function totalSupply() constant returns(uint256) 654 func (_ERC20 *ERC20CallerSession) TotalSupply() (*big.Int, error) { 655 return _ERC20.Contract.TotalSupply(&_ERC20.CallOpts) 656 } 657 658 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 659 // 660 // Solidity: function approve(address _spender, uint256 _value) returns(bool) 661 func (_ERC20 *ERC20Transactor) Approve(opts *bind.TransactOpts, _spender common.Address, _value *big.Int) (*types.Transaction, error) { 662 return _ERC20.contract.Transact(opts, "approve", _spender, _value) 663 } 664 665 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 666 // 667 // Solidity: function approve(address _spender, uint256 _value) returns(bool) 668 func (_ERC20 *ERC20Session) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) { 669 return _ERC20.Contract.Approve(&_ERC20.TransactOpts, _spender, _value) 670 } 671 672 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 673 // 674 // Solidity: function approve(address _spender, uint256 _value) returns(bool) 675 func (_ERC20 *ERC20TransactorSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) { 676 return _ERC20.Contract.Approve(&_ERC20.TransactOpts, _spender, _value) 677 } 678 679 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 680 // 681 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 682 func (_ERC20 *ERC20Transactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error) { 683 return _ERC20.contract.Transact(opts, "transfer", _to, _value) 684 } 685 686 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 687 // 688 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 689 func (_ERC20 *ERC20Session) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { 690 return _ERC20.Contract.Transfer(&_ERC20.TransactOpts, _to, _value) 691 } 692 693 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 694 // 695 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 696 func (_ERC20 *ERC20TransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { 697 return _ERC20.Contract.Transfer(&_ERC20.TransactOpts, _to, _value) 698 } 699 700 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 701 // 702 // Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool) 703 func (_ERC20 *ERC20Transactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { 704 return _ERC20.contract.Transact(opts, "transferFrom", _from, _to, _value) 705 } 706 707 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 708 // 709 // Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool) 710 func (_ERC20 *ERC20Session) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { 711 return _ERC20.Contract.TransferFrom(&_ERC20.TransactOpts, _from, _to, _value) 712 } 713 714 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 715 // 716 // Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool) 717 func (_ERC20 *ERC20TransactorSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { 718 return _ERC20.Contract.TransferFrom(&_ERC20.TransactOpts, _from, _to, _value) 719 } 720 721 // 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. 722 type ERC20ApprovalIterator struct { 723 Event *ERC20Approval // Event containing the contract specifics and raw log 724 725 contract *bind.BoundContract // Generic contract to use for unpacking event data 726 event string // Event name to use for unpacking event data 727 728 logs chan types.Log // Log channel receiving the found contract events 729 sub ethereum.Subscription // Subscription for errors, completion and termination 730 done bool // Whether the subscription completed delivering logs 731 fail error // Occurred error to stop iteration 732 } 733 734 // Next advances the iterator to the subsequent event, returning whether there 735 // are any more events found. In case of a retrieval or parsing error, false is 736 // returned and Error() can be queried for the exact failure. 737 func (it *ERC20ApprovalIterator) Next() bool { 738 // If the iterator failed, stop iterating 739 if it.fail != nil { 740 return false 741 } 742 // If the iterator completed, deliver directly whatever's available 743 if it.done { 744 select { 745 case log := <-it.logs: 746 it.Event = new(ERC20Approval) 747 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 748 it.fail = err 749 return false 750 } 751 it.Event.Raw = log 752 return true 753 754 default: 755 return false 756 } 757 } 758 // Iterator still in progress, wait for either a data or an error event 759 select { 760 case log := <-it.logs: 761 it.Event = new(ERC20Approval) 762 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 763 it.fail = err 764 return false 765 } 766 it.Event.Raw = log 767 return true 768 769 case err := <-it.sub.Err(): 770 it.done = true 771 it.fail = err 772 return it.Next() 773 } 774 } 775 776 // Error returns any retrieval or parsing error occurred during filtering. 777 func (it *ERC20ApprovalIterator) Error() error { 778 return it.fail 779 } 780 781 // Close terminates the iteration process, releasing any pending underlying 782 // resources. 783 func (it *ERC20ApprovalIterator) Close() error { 784 it.sub.Unsubscribe() 785 return nil 786 } 787 788 // ERC20Approval represents a Approval event raised by the ERC20 contract. 789 type ERC20Approval struct { 790 Owner common.Address 791 Spender common.Address 792 Value *big.Int 793 Raw types.Log // Blockchain specific contextual infos 794 } 795 796 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 797 // 798 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 799 func (_ERC20 *ERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20ApprovalIterator, error) { 800 801 var ownerRule []interface{} 802 for _, ownerItem := range owner { 803 ownerRule = append(ownerRule, ownerItem) 804 } 805 var spenderRule []interface{} 806 for _, spenderItem := range spender { 807 spenderRule = append(spenderRule, spenderItem) 808 } 809 810 logs, sub, err := _ERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 811 if err != nil { 812 return nil, err 813 } 814 return &ERC20ApprovalIterator{contract: _ERC20.contract, event: "Approval", logs: logs, sub: sub}, nil 815 } 816 817 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 818 // 819 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 820 func (_ERC20 *ERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 821 822 var ownerRule []interface{} 823 for _, ownerItem := range owner { 824 ownerRule = append(ownerRule, ownerItem) 825 } 826 var spenderRule []interface{} 827 for _, spenderItem := range spender { 828 spenderRule = append(spenderRule, spenderItem) 829 } 830 831 logs, sub, err := _ERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 832 if err != nil { 833 return nil, err 834 } 835 return event.NewSubscription(func(quit <-chan struct{}) error { 836 defer sub.Unsubscribe() 837 for { 838 select { 839 case log := <-logs: 840 // New log arrived, parse the event and forward to the user 841 event := new(ERC20Approval) 842 if err := _ERC20.contract.UnpackLog(event, "Approval", log); err != nil { 843 return err 844 } 845 event.Raw = log 846 847 select { 848 case sink <- event: 849 case err := <-sub.Err(): 850 return err 851 case <-quit: 852 return nil 853 } 854 case err := <-sub.Err(): 855 return err 856 case <-quit: 857 return nil 858 } 859 } 860 }), nil 861 } 862 863 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 864 // 865 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 866 func (_ERC20 *ERC20Filterer) ParseApproval(log types.Log) (*ERC20Approval, error) { 867 event := new(ERC20Approval) 868 if err := _ERC20.contract.UnpackLog(event, "Approval", log); err != nil { 869 return nil, err 870 } 871 return event, nil 872 } 873 874 // 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. 875 type ERC20TransferIterator struct { 876 Event *ERC20Transfer // Event containing the contract specifics and raw log 877 878 contract *bind.BoundContract // Generic contract to use for unpacking event data 879 event string // Event name to use for unpacking event data 880 881 logs chan types.Log // Log channel receiving the found contract events 882 sub ethereum.Subscription // Subscription for errors, completion and termination 883 done bool // Whether the subscription completed delivering logs 884 fail error // Occurred error to stop iteration 885 } 886 887 // Next advances the iterator to the subsequent event, returning whether there 888 // are any more events found. In case of a retrieval or parsing error, false is 889 // returned and Error() can be queried for the exact failure. 890 func (it *ERC20TransferIterator) Next() bool { 891 // If the iterator failed, stop iterating 892 if it.fail != nil { 893 return false 894 } 895 // If the iterator completed, deliver directly whatever's available 896 if it.done { 897 select { 898 case log := <-it.logs: 899 it.Event = new(ERC20Transfer) 900 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 901 it.fail = err 902 return false 903 } 904 it.Event.Raw = log 905 return true 906 907 default: 908 return false 909 } 910 } 911 // Iterator still in progress, wait for either a data or an error event 912 select { 913 case log := <-it.logs: 914 it.Event = new(ERC20Transfer) 915 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 916 it.fail = err 917 return false 918 } 919 it.Event.Raw = log 920 return true 921 922 case err := <-it.sub.Err(): 923 it.done = true 924 it.fail = err 925 return it.Next() 926 } 927 } 928 929 // Error returns any retrieval or parsing error occurred during filtering. 930 func (it *ERC20TransferIterator) Error() error { 931 return it.fail 932 } 933 934 // Close terminates the iteration process, releasing any pending underlying 935 // resources. 936 func (it *ERC20TransferIterator) Close() error { 937 it.sub.Unsubscribe() 938 return nil 939 } 940 941 // ERC20Transfer represents a Transfer event raised by the ERC20 contract. 942 type ERC20Transfer struct { 943 From common.Address 944 To common.Address 945 Value *big.Int 946 Raw types.Log // Blockchain specific contextual infos 947 } 948 949 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 950 // 951 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 952 func (_ERC20 *ERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20TransferIterator, error) { 953 954 var fromRule []interface{} 955 for _, fromItem := range from { 956 fromRule = append(fromRule, fromItem) 957 } 958 var toRule []interface{} 959 for _, toItem := range to { 960 toRule = append(toRule, toItem) 961 } 962 963 logs, sub, err := _ERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 964 if err != nil { 965 return nil, err 966 } 967 return &ERC20TransferIterator{contract: _ERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil 968 } 969 970 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 971 // 972 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 973 func (_ERC20 *ERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) { 974 975 var fromRule []interface{} 976 for _, fromItem := range from { 977 fromRule = append(fromRule, fromItem) 978 } 979 var toRule []interface{} 980 for _, toItem := range to { 981 toRule = append(toRule, toItem) 982 } 983 984 logs, sub, err := _ERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 985 if err != nil { 986 return nil, err 987 } 988 return event.NewSubscription(func(quit <-chan struct{}) error { 989 defer sub.Unsubscribe() 990 for { 991 select { 992 case log := <-logs: 993 // New log arrived, parse the event and forward to the user 994 event := new(ERC20Transfer) 995 if err := _ERC20.contract.UnpackLog(event, "Transfer", log); err != nil { 996 return err 997 } 998 event.Raw = log 999 1000 select { 1001 case sink <- event: 1002 case err := <-sub.Err(): 1003 return err 1004 case <-quit: 1005 return nil 1006 } 1007 case err := <-sub.Err(): 1008 return err 1009 case <-quit: 1010 return nil 1011 } 1012 } 1013 }), nil 1014 } 1015 1016 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 1017 // 1018 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 1019 func (_ERC20 *ERC20Filterer) ParseTransfer(log types.Log) (*ERC20Transfer, error) { 1020 event := new(ERC20Transfer) 1021 if err := _ERC20.contract.UnpackLog(event, "Transfer", log); err != nil { 1022 return nil, err 1023 } 1024 return event, nil 1025 } 1026 1027 // ERC20BasicABI is the input ABI used to generate the binding from. 1028 const ERC20BasicABI = "[{\"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\":\"_who\",\"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\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 1029 1030 // ERC20BasicFuncSigs maps the 4-byte function signature to its string representation. 1031 var ERC20BasicFuncSigs = map[string]string{ 1032 "70a08231": "balanceOf(address)", 1033 "18160ddd": "totalSupply()", 1034 "a9059cbb": "transfer(address,uint256)", 1035 } 1036 1037 // ERC20Basic is an auto generated Go binding around an Ethereum contract. 1038 type ERC20Basic struct { 1039 ERC20BasicCaller // Read-only binding to the contract 1040 ERC20BasicTransactor // Write-only binding to the contract 1041 ERC20BasicFilterer // Log filterer for contract events 1042 } 1043 1044 // ERC20BasicCaller is an auto generated read-only Go binding around an Ethereum contract. 1045 type ERC20BasicCaller struct { 1046 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1047 } 1048 1049 // ERC20BasicTransactor is an auto generated write-only Go binding around an Ethereum contract. 1050 type ERC20BasicTransactor struct { 1051 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1052 } 1053 1054 // ERC20BasicFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 1055 type ERC20BasicFilterer struct { 1056 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1057 } 1058 1059 // ERC20BasicSession is an auto generated Go binding around an Ethereum contract, 1060 // with pre-set call and transact options. 1061 type ERC20BasicSession struct { 1062 Contract *ERC20Basic // Generic contract binding to set the session for 1063 CallOpts bind.CallOpts // Call options to use throughout this session 1064 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 1065 } 1066 1067 // ERC20BasicCallerSession is an auto generated read-only Go binding around an Ethereum contract, 1068 // with pre-set call options. 1069 type ERC20BasicCallerSession struct { 1070 Contract *ERC20BasicCaller // Generic contract caller binding to set the session for 1071 CallOpts bind.CallOpts // Call options to use throughout this session 1072 } 1073 1074 // ERC20BasicTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 1075 // with pre-set transact options. 1076 type ERC20BasicTransactorSession struct { 1077 Contract *ERC20BasicTransactor // Generic contract transactor binding to set the session for 1078 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 1079 } 1080 1081 // ERC20BasicRaw is an auto generated low-level Go binding around an Ethereum contract. 1082 type ERC20BasicRaw struct { 1083 Contract *ERC20Basic // Generic contract binding to access the raw methods on 1084 } 1085 1086 // ERC20BasicCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 1087 type ERC20BasicCallerRaw struct { 1088 Contract *ERC20BasicCaller // Generic read-only contract binding to access the raw methods on 1089 } 1090 1091 // ERC20BasicTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 1092 type ERC20BasicTransactorRaw struct { 1093 Contract *ERC20BasicTransactor // Generic write-only contract binding to access the raw methods on 1094 } 1095 1096 // NewERC20Basic creates a new instance of ERC20Basic, bound to a specific deployed contract. 1097 func NewERC20Basic(address common.Address, backend bind.ContractBackend) (*ERC20Basic, error) { 1098 contract, err := bindERC20Basic(address, backend, backend, backend) 1099 if err != nil { 1100 return nil, err 1101 } 1102 return &ERC20Basic{ERC20BasicCaller: ERC20BasicCaller{contract: contract}, ERC20BasicTransactor: ERC20BasicTransactor{contract: contract}, ERC20BasicFilterer: ERC20BasicFilterer{contract: contract}}, nil 1103 } 1104 1105 // NewERC20BasicCaller creates a new read-only instance of ERC20Basic, bound to a specific deployed contract. 1106 func NewERC20BasicCaller(address common.Address, caller bind.ContractCaller) (*ERC20BasicCaller, error) { 1107 contract, err := bindERC20Basic(address, caller, nil, nil) 1108 if err != nil { 1109 return nil, err 1110 } 1111 return &ERC20BasicCaller{contract: contract}, nil 1112 } 1113 1114 // NewERC20BasicTransactor creates a new write-only instance of ERC20Basic, bound to a specific deployed contract. 1115 func NewERC20BasicTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20BasicTransactor, error) { 1116 contract, err := bindERC20Basic(address, nil, transactor, nil) 1117 if err != nil { 1118 return nil, err 1119 } 1120 return &ERC20BasicTransactor{contract: contract}, nil 1121 } 1122 1123 // NewERC20BasicFilterer creates a new log filterer instance of ERC20Basic, bound to a specific deployed contract. 1124 func NewERC20BasicFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20BasicFilterer, error) { 1125 contract, err := bindERC20Basic(address, nil, nil, filterer) 1126 if err != nil { 1127 return nil, err 1128 } 1129 return &ERC20BasicFilterer{contract: contract}, nil 1130 } 1131 1132 // bindERC20Basic binds a generic wrapper to an already deployed contract. 1133 func bindERC20Basic(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 1134 parsed, err := abi.JSON(strings.NewReader(ERC20BasicABI)) 1135 if err != nil { 1136 return nil, err 1137 } 1138 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 1139 } 1140 1141 // Call invokes the (constant) contract method with params as input values and 1142 // sets the output to result. The result type might be a single field for simple 1143 // returns, a slice of interfaces for anonymous returns and a struct for named 1144 // returns. 1145 func (_ERC20Basic *ERC20BasicRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 1146 return _ERC20Basic.Contract.ERC20BasicCaller.contract.Call(opts, result, method, params...) 1147 } 1148 1149 // Transfer initiates a plain transaction to move funds to the contract, calling 1150 // its default method if one is available. 1151 func (_ERC20Basic *ERC20BasicRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 1152 return _ERC20Basic.Contract.ERC20BasicTransactor.contract.Transfer(opts) 1153 } 1154 1155 // Transact invokes the (paid) contract method with params as input values. 1156 func (_ERC20Basic *ERC20BasicRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1157 return _ERC20Basic.Contract.ERC20BasicTransactor.contract.Transact(opts, method, params...) 1158 } 1159 1160 // Call invokes the (constant) contract method with params as input values and 1161 // sets the output to result. The result type might be a single field for simple 1162 // returns, a slice of interfaces for anonymous returns and a struct for named 1163 // returns. 1164 func (_ERC20Basic *ERC20BasicCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 1165 return _ERC20Basic.Contract.contract.Call(opts, result, method, params...) 1166 } 1167 1168 // Transfer initiates a plain transaction to move funds to the contract, calling 1169 // its default method if one is available. 1170 func (_ERC20Basic *ERC20BasicTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 1171 return _ERC20Basic.Contract.contract.Transfer(opts) 1172 } 1173 1174 // Transact invokes the (paid) contract method with params as input values. 1175 func (_ERC20Basic *ERC20BasicTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1176 return _ERC20Basic.Contract.contract.Transact(opts, method, params...) 1177 } 1178 1179 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 1180 // 1181 // Solidity: function balanceOf(address _who) constant returns(uint256) 1182 func (_ERC20Basic *ERC20BasicCaller) BalanceOf(opts *bind.CallOpts, _who common.Address) (*big.Int, error) { 1183 var ( 1184 ret0 = new(*big.Int) 1185 ) 1186 out := ret0 1187 err := _ERC20Basic.contract.Call(opts, out, "balanceOf", _who) 1188 return *ret0, err 1189 } 1190 1191 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 1192 // 1193 // Solidity: function balanceOf(address _who) constant returns(uint256) 1194 func (_ERC20Basic *ERC20BasicSession) BalanceOf(_who common.Address) (*big.Int, error) { 1195 return _ERC20Basic.Contract.BalanceOf(&_ERC20Basic.CallOpts, _who) 1196 } 1197 1198 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 1199 // 1200 // Solidity: function balanceOf(address _who) constant returns(uint256) 1201 func (_ERC20Basic *ERC20BasicCallerSession) BalanceOf(_who common.Address) (*big.Int, error) { 1202 return _ERC20Basic.Contract.BalanceOf(&_ERC20Basic.CallOpts, _who) 1203 } 1204 1205 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1206 // 1207 // Solidity: function totalSupply() constant returns(uint256) 1208 func (_ERC20Basic *ERC20BasicCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 1209 var ( 1210 ret0 = new(*big.Int) 1211 ) 1212 out := ret0 1213 err := _ERC20Basic.contract.Call(opts, out, "totalSupply") 1214 return *ret0, err 1215 } 1216 1217 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1218 // 1219 // Solidity: function totalSupply() constant returns(uint256) 1220 func (_ERC20Basic *ERC20BasicSession) TotalSupply() (*big.Int, error) { 1221 return _ERC20Basic.Contract.TotalSupply(&_ERC20Basic.CallOpts) 1222 } 1223 1224 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1225 // 1226 // Solidity: function totalSupply() constant returns(uint256) 1227 func (_ERC20Basic *ERC20BasicCallerSession) TotalSupply() (*big.Int, error) { 1228 return _ERC20Basic.Contract.TotalSupply(&_ERC20Basic.CallOpts) 1229 } 1230 1231 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 1232 // 1233 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 1234 func (_ERC20Basic *ERC20BasicTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error) { 1235 return _ERC20Basic.contract.Transact(opts, "transfer", _to, _value) 1236 } 1237 1238 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 1239 // 1240 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 1241 func (_ERC20Basic *ERC20BasicSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { 1242 return _ERC20Basic.Contract.Transfer(&_ERC20Basic.TransactOpts, _to, _value) 1243 } 1244 1245 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 1246 // 1247 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 1248 func (_ERC20Basic *ERC20BasicTransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { 1249 return _ERC20Basic.Contract.Transfer(&_ERC20Basic.TransactOpts, _to, _value) 1250 } 1251 1252 // ERC20BasicTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20Basic contract. 1253 type ERC20BasicTransferIterator struct { 1254 Event *ERC20BasicTransfer // Event containing the contract specifics and raw log 1255 1256 contract *bind.BoundContract // Generic contract to use for unpacking event data 1257 event string // Event name to use for unpacking event data 1258 1259 logs chan types.Log // Log channel receiving the found contract events 1260 sub ethereum.Subscription // Subscription for errors, completion and termination 1261 done bool // Whether the subscription completed delivering logs 1262 fail error // Occurred error to stop iteration 1263 } 1264 1265 // Next advances the iterator to the subsequent event, returning whether there 1266 // are any more events found. In case of a retrieval or parsing error, false is 1267 // returned and Error() can be queried for the exact failure. 1268 func (it *ERC20BasicTransferIterator) Next() bool { 1269 // If the iterator failed, stop iterating 1270 if it.fail != nil { 1271 return false 1272 } 1273 // If the iterator completed, deliver directly whatever's available 1274 if it.done { 1275 select { 1276 case log := <-it.logs: 1277 it.Event = new(ERC20BasicTransfer) 1278 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1279 it.fail = err 1280 return false 1281 } 1282 it.Event.Raw = log 1283 return true 1284 1285 default: 1286 return false 1287 } 1288 } 1289 // Iterator still in progress, wait for either a data or an error event 1290 select { 1291 case log := <-it.logs: 1292 it.Event = new(ERC20BasicTransfer) 1293 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1294 it.fail = err 1295 return false 1296 } 1297 it.Event.Raw = log 1298 return true 1299 1300 case err := <-it.sub.Err(): 1301 it.done = true 1302 it.fail = err 1303 return it.Next() 1304 } 1305 } 1306 1307 // Error returns any retrieval or parsing error occurred during filtering. 1308 func (it *ERC20BasicTransferIterator) Error() error { 1309 return it.fail 1310 } 1311 1312 // Close terminates the iteration process, releasing any pending underlying 1313 // resources. 1314 func (it *ERC20BasicTransferIterator) Close() error { 1315 it.sub.Unsubscribe() 1316 return nil 1317 } 1318 1319 // ERC20BasicTransfer represents a Transfer event raised by the ERC20Basic contract. 1320 type ERC20BasicTransfer struct { 1321 From common.Address 1322 To common.Address 1323 Value *big.Int 1324 Raw types.Log // Blockchain specific contextual infos 1325 } 1326 1327 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 1328 // 1329 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 1330 func (_ERC20Basic *ERC20BasicFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20BasicTransferIterator, error) { 1331 1332 var fromRule []interface{} 1333 for _, fromItem := range from { 1334 fromRule = append(fromRule, fromItem) 1335 } 1336 var toRule []interface{} 1337 for _, toItem := range to { 1338 toRule = append(toRule, toItem) 1339 } 1340 1341 logs, sub, err := _ERC20Basic.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 1342 if err != nil { 1343 return nil, err 1344 } 1345 return &ERC20BasicTransferIterator{contract: _ERC20Basic.contract, event: "Transfer", logs: logs, sub: sub}, nil 1346 } 1347 1348 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 1349 // 1350 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 1351 func (_ERC20Basic *ERC20BasicFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20BasicTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 1352 1353 var fromRule []interface{} 1354 for _, fromItem := range from { 1355 fromRule = append(fromRule, fromItem) 1356 } 1357 var toRule []interface{} 1358 for _, toItem := range to { 1359 toRule = append(toRule, toItem) 1360 } 1361 1362 logs, sub, err := _ERC20Basic.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 1363 if err != nil { 1364 return nil, err 1365 } 1366 return event.NewSubscription(func(quit <-chan struct{}) error { 1367 defer sub.Unsubscribe() 1368 for { 1369 select { 1370 case log := <-logs: 1371 // New log arrived, parse the event and forward to the user 1372 event := new(ERC20BasicTransfer) 1373 if err := _ERC20Basic.contract.UnpackLog(event, "Transfer", log); err != nil { 1374 return err 1375 } 1376 event.Raw = log 1377 1378 select { 1379 case sink <- event: 1380 case err := <-sub.Err(): 1381 return err 1382 case <-quit: 1383 return nil 1384 } 1385 case err := <-sub.Err(): 1386 return err 1387 case <-quit: 1388 return nil 1389 } 1390 } 1391 }), nil 1392 } 1393 1394 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 1395 // 1396 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 1397 func (_ERC20Basic *ERC20BasicFilterer) ParseTransfer(log types.Log) (*ERC20BasicTransfer, error) { 1398 event := new(ERC20BasicTransfer) 1399 if err := _ERC20Basic.contract.UnpackLog(event, "Transfer", log); err != nil { 1400 return nil, err 1401 } 1402 return event, nil 1403 } 1404 1405 // EtherTokenABI is the input ABI used to generate the binding from. 1406 const EtherTokenABI = "[{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"_development\",\"type\":\"bool\"},{\"internalType\":\"contractERC20\",\"name\":\"_token\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"_swapEnabled\",\"type\":\"bool\"}],\"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\":false,\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"Depositted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"_isExit\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_requestor\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"_trieKey\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"RequestCreated\",\"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\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"Withdrawn\",\"type\":\"event\"},{\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"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\":\"bool\",\"name\":\"isExit\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"requestId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"requestor\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"trieKey\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"trieValue\",\"type\":\"bytes\"}],\"name\":\"applyRequestInChildChain\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"isExit\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"requestId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"requestor\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"trieKey\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"trieValue\",\"type\":\"bytes\"}],\"name\":\"applyRequestInRootChain\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"trieValue\",\"type\":\"bytes\"}],\"name\":\"decodeTrieValue\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"v\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseApproval\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"development\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_who\",\"type\":\"address\"}],\"name\":\"getBalanceTrieKey\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseApproval\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_rootchain\",\"type\":\"address\"}],\"name\":\"init\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"initialized\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"rootchain\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"swapEnabled\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"swapFromEth\",\"outputs\":[],\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"swapToEth\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"token\",\"outputs\":[{\"internalType\":\"contractERC20\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 1407 1408 // EtherTokenFuncSigs maps the 4-byte function signature to its string representation. 1409 var EtherTokenFuncSigs = map[string]string{ 1410 "dd62ed3e": "allowance(address,address)", 1411 "141ecf46": "applyRequestInChildChain(bool,uint256,address,bytes32,bytes)", 1412 "a9f79308": "applyRequestInRootChain(bool,uint256,address,bytes32,bytes)", 1413 "095ea7b3": "approve(address,uint256)", 1414 "70a08231": "balanceOf(address)", 1415 "b9e59d09": "decodeTrieValue(bytes)", 1416 "66188463": "decreaseApproval(address,uint256)", 1417 "b6b55f25": "deposit(uint256)", 1418 "7b929c27": "development()", 1419 "b18fcfdf": "getBalanceTrieKey(address)", 1420 "d73dd623": "increaseApproval(address,uint256)", 1421 "19ab453c": "init(address)", 1422 "158ef93e": "initialized()", 1423 "bcc7874d": "rootchain()", 1424 "6ddd1713": "swapEnabled()", 1425 "59310da7": "swapFromEth()", 1426 "b06c6729": "swapToEth(uint256)", 1427 "fc0c546a": "token()", 1428 "18160ddd": "totalSupply()", 1429 "a9059cbb": "transfer(address,uint256)", 1430 "23b872dd": "transferFrom(address,address,uint256)", 1431 "2e1a7d4d": "withdraw(uint256)", 1432 } 1433 1434 // EtherTokenBin is the compiled bytecode used for deploying new contracts. 1435 var EtherTokenBin = "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" 1436 1437 // DeployEtherToken deploys a new Ethereum contract, binding an instance of EtherToken to it. 1438 func DeployEtherToken(auth *bind.TransactOpts, backend bind.ContractBackend, _development bool, _token common.Address, _swapEnabled bool) (common.Address, *types.Transaction, *EtherToken, error) { 1439 parsed, err := abi.JSON(strings.NewReader(EtherTokenABI)) 1440 if err != nil { 1441 return common.Address{}, nil, nil, err 1442 } 1443 1444 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(EtherTokenBin), backend, _development, _token, _swapEnabled) 1445 if err != nil { 1446 return common.Address{}, nil, nil, err 1447 } 1448 return address, tx, &EtherToken{EtherTokenCaller: EtherTokenCaller{contract: contract}, EtherTokenTransactor: EtherTokenTransactor{contract: contract}, EtherTokenFilterer: EtherTokenFilterer{contract: contract}}, nil 1449 } 1450 1451 // EtherToken is an auto generated Go binding around an Ethereum contract. 1452 type EtherToken struct { 1453 EtherTokenCaller // Read-only binding to the contract 1454 EtherTokenTransactor // Write-only binding to the contract 1455 EtherTokenFilterer // Log filterer for contract events 1456 } 1457 1458 // EtherTokenCaller is an auto generated read-only Go binding around an Ethereum contract. 1459 type EtherTokenCaller struct { 1460 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1461 } 1462 1463 // EtherTokenTransactor is an auto generated write-only Go binding around an Ethereum contract. 1464 type EtherTokenTransactor struct { 1465 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1466 } 1467 1468 // EtherTokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 1469 type EtherTokenFilterer struct { 1470 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1471 } 1472 1473 // EtherTokenSession is an auto generated Go binding around an Ethereum contract, 1474 // with pre-set call and transact options. 1475 type EtherTokenSession struct { 1476 Contract *EtherToken // Generic contract binding to set the session for 1477 CallOpts bind.CallOpts // Call options to use throughout this session 1478 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 1479 } 1480 1481 // EtherTokenCallerSession is an auto generated read-only Go binding around an Ethereum contract, 1482 // with pre-set call options. 1483 type EtherTokenCallerSession struct { 1484 Contract *EtherTokenCaller // Generic contract caller binding to set the session for 1485 CallOpts bind.CallOpts // Call options to use throughout this session 1486 } 1487 1488 // EtherTokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 1489 // with pre-set transact options. 1490 type EtherTokenTransactorSession struct { 1491 Contract *EtherTokenTransactor // Generic contract transactor binding to set the session for 1492 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 1493 } 1494 1495 // EtherTokenRaw is an auto generated low-level Go binding around an Ethereum contract. 1496 type EtherTokenRaw struct { 1497 Contract *EtherToken // Generic contract binding to access the raw methods on 1498 } 1499 1500 // EtherTokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 1501 type EtherTokenCallerRaw struct { 1502 Contract *EtherTokenCaller // Generic read-only contract binding to access the raw methods on 1503 } 1504 1505 // EtherTokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 1506 type EtherTokenTransactorRaw struct { 1507 Contract *EtherTokenTransactor // Generic write-only contract binding to access the raw methods on 1508 } 1509 1510 // NewEtherToken creates a new instance of EtherToken, bound to a specific deployed contract. 1511 func NewEtherToken(address common.Address, backend bind.ContractBackend) (*EtherToken, error) { 1512 contract, err := bindEtherToken(address, backend, backend, backend) 1513 if err != nil { 1514 return nil, err 1515 } 1516 return &EtherToken{EtherTokenCaller: EtherTokenCaller{contract: contract}, EtherTokenTransactor: EtherTokenTransactor{contract: contract}, EtherTokenFilterer: EtherTokenFilterer{contract: contract}}, nil 1517 } 1518 1519 // NewEtherTokenCaller creates a new read-only instance of EtherToken, bound to a specific deployed contract. 1520 func NewEtherTokenCaller(address common.Address, caller bind.ContractCaller) (*EtherTokenCaller, error) { 1521 contract, err := bindEtherToken(address, caller, nil, nil) 1522 if err != nil { 1523 return nil, err 1524 } 1525 return &EtherTokenCaller{contract: contract}, nil 1526 } 1527 1528 // NewEtherTokenTransactor creates a new write-only instance of EtherToken, bound to a specific deployed contract. 1529 func NewEtherTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*EtherTokenTransactor, error) { 1530 contract, err := bindEtherToken(address, nil, transactor, nil) 1531 if err != nil { 1532 return nil, err 1533 } 1534 return &EtherTokenTransactor{contract: contract}, nil 1535 } 1536 1537 // NewEtherTokenFilterer creates a new log filterer instance of EtherToken, bound to a specific deployed contract. 1538 func NewEtherTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*EtherTokenFilterer, error) { 1539 contract, err := bindEtherToken(address, nil, nil, filterer) 1540 if err != nil { 1541 return nil, err 1542 } 1543 return &EtherTokenFilterer{contract: contract}, nil 1544 } 1545 1546 // bindEtherToken binds a generic wrapper to an already deployed contract. 1547 func bindEtherToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 1548 parsed, err := abi.JSON(strings.NewReader(EtherTokenABI)) 1549 if err != nil { 1550 return nil, err 1551 } 1552 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 1553 } 1554 1555 // Call invokes the (constant) contract method with params as input values and 1556 // sets the output to result. The result type might be a single field for simple 1557 // returns, a slice of interfaces for anonymous returns and a struct for named 1558 // returns. 1559 func (_EtherToken *EtherTokenRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 1560 return _EtherToken.Contract.EtherTokenCaller.contract.Call(opts, result, method, params...) 1561 } 1562 1563 // Transfer initiates a plain transaction to move funds to the contract, calling 1564 // its default method if one is available. 1565 func (_EtherToken *EtherTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 1566 return _EtherToken.Contract.EtherTokenTransactor.contract.Transfer(opts) 1567 } 1568 1569 // Transact invokes the (paid) contract method with params as input values. 1570 func (_EtherToken *EtherTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1571 return _EtherToken.Contract.EtherTokenTransactor.contract.Transact(opts, method, params...) 1572 } 1573 1574 // Call invokes the (constant) contract method with params as input values and 1575 // sets the output to result. The result type might be a single field for simple 1576 // returns, a slice of interfaces for anonymous returns and a struct for named 1577 // returns. 1578 func (_EtherToken *EtherTokenCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 1579 return _EtherToken.Contract.contract.Call(opts, result, method, params...) 1580 } 1581 1582 // Transfer initiates a plain transaction to move funds to the contract, calling 1583 // its default method if one is available. 1584 func (_EtherToken *EtherTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 1585 return _EtherToken.Contract.contract.Transfer(opts) 1586 } 1587 1588 // Transact invokes the (paid) contract method with params as input values. 1589 func (_EtherToken *EtherTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1590 return _EtherToken.Contract.contract.Transact(opts, method, params...) 1591 } 1592 1593 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 1594 // 1595 // Solidity: function allowance(address _owner, address _spender) constant returns(uint256) 1596 func (_EtherToken *EtherTokenCaller) Allowance(opts *bind.CallOpts, _owner common.Address, _spender common.Address) (*big.Int, error) { 1597 var ( 1598 ret0 = new(*big.Int) 1599 ) 1600 out := ret0 1601 err := _EtherToken.contract.Call(opts, out, "allowance", _owner, _spender) 1602 return *ret0, err 1603 } 1604 1605 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 1606 // 1607 // Solidity: function allowance(address _owner, address _spender) constant returns(uint256) 1608 func (_EtherToken *EtherTokenSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) { 1609 return _EtherToken.Contract.Allowance(&_EtherToken.CallOpts, _owner, _spender) 1610 } 1611 1612 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 1613 // 1614 // Solidity: function allowance(address _owner, address _spender) constant returns(uint256) 1615 func (_EtherToken *EtherTokenCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) { 1616 return _EtherToken.Contract.Allowance(&_EtherToken.CallOpts, _owner, _spender) 1617 } 1618 1619 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 1620 // 1621 // Solidity: function balanceOf(address _owner) constant returns(uint256) 1622 func (_EtherToken *EtherTokenCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) { 1623 var ( 1624 ret0 = new(*big.Int) 1625 ) 1626 out := ret0 1627 err := _EtherToken.contract.Call(opts, out, "balanceOf", _owner) 1628 return *ret0, err 1629 } 1630 1631 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 1632 // 1633 // Solidity: function balanceOf(address _owner) constant returns(uint256) 1634 func (_EtherToken *EtherTokenSession) BalanceOf(_owner common.Address) (*big.Int, error) { 1635 return _EtherToken.Contract.BalanceOf(&_EtherToken.CallOpts, _owner) 1636 } 1637 1638 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 1639 // 1640 // Solidity: function balanceOf(address _owner) constant returns(uint256) 1641 func (_EtherToken *EtherTokenCallerSession) BalanceOf(_owner common.Address) (*big.Int, error) { 1642 return _EtherToken.Contract.BalanceOf(&_EtherToken.CallOpts, _owner) 1643 } 1644 1645 // DecodeTrieValue is a free data retrieval call binding the contract method 0xb9e59d09. 1646 // 1647 // Solidity: function decodeTrieValue(bytes trieValue) constant returns(uint256 v) 1648 func (_EtherToken *EtherTokenCaller) DecodeTrieValue(opts *bind.CallOpts, trieValue []byte) (*big.Int, error) { 1649 var ( 1650 ret0 = new(*big.Int) 1651 ) 1652 out := ret0 1653 err := _EtherToken.contract.Call(opts, out, "decodeTrieValue", trieValue) 1654 return *ret0, err 1655 } 1656 1657 // DecodeTrieValue is a free data retrieval call binding the contract method 0xb9e59d09. 1658 // 1659 // Solidity: function decodeTrieValue(bytes trieValue) constant returns(uint256 v) 1660 func (_EtherToken *EtherTokenSession) DecodeTrieValue(trieValue []byte) (*big.Int, error) { 1661 return _EtherToken.Contract.DecodeTrieValue(&_EtherToken.CallOpts, trieValue) 1662 } 1663 1664 // DecodeTrieValue is a free data retrieval call binding the contract method 0xb9e59d09. 1665 // 1666 // Solidity: function decodeTrieValue(bytes trieValue) constant returns(uint256 v) 1667 func (_EtherToken *EtherTokenCallerSession) DecodeTrieValue(trieValue []byte) (*big.Int, error) { 1668 return _EtherToken.Contract.DecodeTrieValue(&_EtherToken.CallOpts, trieValue) 1669 } 1670 1671 // Development is a free data retrieval call binding the contract method 0x7b929c27. 1672 // 1673 // Solidity: function development() constant returns(bool) 1674 func (_EtherToken *EtherTokenCaller) Development(opts *bind.CallOpts) (bool, error) { 1675 var ( 1676 ret0 = new(bool) 1677 ) 1678 out := ret0 1679 err := _EtherToken.contract.Call(opts, out, "development") 1680 return *ret0, err 1681 } 1682 1683 // Development is a free data retrieval call binding the contract method 0x7b929c27. 1684 // 1685 // Solidity: function development() constant returns(bool) 1686 func (_EtherToken *EtherTokenSession) Development() (bool, error) { 1687 return _EtherToken.Contract.Development(&_EtherToken.CallOpts) 1688 } 1689 1690 // Development is a free data retrieval call binding the contract method 0x7b929c27. 1691 // 1692 // Solidity: function development() constant returns(bool) 1693 func (_EtherToken *EtherTokenCallerSession) Development() (bool, error) { 1694 return _EtherToken.Contract.Development(&_EtherToken.CallOpts) 1695 } 1696 1697 // GetBalanceTrieKey is a free data retrieval call binding the contract method 0xb18fcfdf. 1698 // 1699 // Solidity: function getBalanceTrieKey(address _who) constant returns(bytes32) 1700 func (_EtherToken *EtherTokenCaller) GetBalanceTrieKey(opts *bind.CallOpts, _who common.Address) ([32]byte, error) { 1701 var ( 1702 ret0 = new([32]byte) 1703 ) 1704 out := ret0 1705 err := _EtherToken.contract.Call(opts, out, "getBalanceTrieKey", _who) 1706 return *ret0, err 1707 } 1708 1709 // GetBalanceTrieKey is a free data retrieval call binding the contract method 0xb18fcfdf. 1710 // 1711 // Solidity: function getBalanceTrieKey(address _who) constant returns(bytes32) 1712 func (_EtherToken *EtherTokenSession) GetBalanceTrieKey(_who common.Address) ([32]byte, error) { 1713 return _EtherToken.Contract.GetBalanceTrieKey(&_EtherToken.CallOpts, _who) 1714 } 1715 1716 // GetBalanceTrieKey is a free data retrieval call binding the contract method 0xb18fcfdf. 1717 // 1718 // Solidity: function getBalanceTrieKey(address _who) constant returns(bytes32) 1719 func (_EtherToken *EtherTokenCallerSession) GetBalanceTrieKey(_who common.Address) ([32]byte, error) { 1720 return _EtherToken.Contract.GetBalanceTrieKey(&_EtherToken.CallOpts, _who) 1721 } 1722 1723 // Initialized is a free data retrieval call binding the contract method 0x158ef93e. 1724 // 1725 // Solidity: function initialized() constant returns(bool) 1726 func (_EtherToken *EtherTokenCaller) Initialized(opts *bind.CallOpts) (bool, error) { 1727 var ( 1728 ret0 = new(bool) 1729 ) 1730 out := ret0 1731 err := _EtherToken.contract.Call(opts, out, "initialized") 1732 return *ret0, err 1733 } 1734 1735 // Initialized is a free data retrieval call binding the contract method 0x158ef93e. 1736 // 1737 // Solidity: function initialized() constant returns(bool) 1738 func (_EtherToken *EtherTokenSession) Initialized() (bool, error) { 1739 return _EtherToken.Contract.Initialized(&_EtherToken.CallOpts) 1740 } 1741 1742 // Initialized is a free data retrieval call binding the contract method 0x158ef93e. 1743 // 1744 // Solidity: function initialized() constant returns(bool) 1745 func (_EtherToken *EtherTokenCallerSession) Initialized() (bool, error) { 1746 return _EtherToken.Contract.Initialized(&_EtherToken.CallOpts) 1747 } 1748 1749 // Rootchain is a free data retrieval call binding the contract method 0xbcc7874d. 1750 // 1751 // Solidity: function rootchain() constant returns(address) 1752 func (_EtherToken *EtherTokenCaller) Rootchain(opts *bind.CallOpts) (common.Address, error) { 1753 var ( 1754 ret0 = new(common.Address) 1755 ) 1756 out := ret0 1757 err := _EtherToken.contract.Call(opts, out, "rootchain") 1758 return *ret0, err 1759 } 1760 1761 // Rootchain is a free data retrieval call binding the contract method 0xbcc7874d. 1762 // 1763 // Solidity: function rootchain() constant returns(address) 1764 func (_EtherToken *EtherTokenSession) Rootchain() (common.Address, error) { 1765 return _EtherToken.Contract.Rootchain(&_EtherToken.CallOpts) 1766 } 1767 1768 // Rootchain is a free data retrieval call binding the contract method 0xbcc7874d. 1769 // 1770 // Solidity: function rootchain() constant returns(address) 1771 func (_EtherToken *EtherTokenCallerSession) Rootchain() (common.Address, error) { 1772 return _EtherToken.Contract.Rootchain(&_EtherToken.CallOpts) 1773 } 1774 1775 // SwapEnabled is a free data retrieval call binding the contract method 0x6ddd1713. 1776 // 1777 // Solidity: function swapEnabled() constant returns(bool) 1778 func (_EtherToken *EtherTokenCaller) SwapEnabled(opts *bind.CallOpts) (bool, error) { 1779 var ( 1780 ret0 = new(bool) 1781 ) 1782 out := ret0 1783 err := _EtherToken.contract.Call(opts, out, "swapEnabled") 1784 return *ret0, err 1785 } 1786 1787 // SwapEnabled is a free data retrieval call binding the contract method 0x6ddd1713. 1788 // 1789 // Solidity: function swapEnabled() constant returns(bool) 1790 func (_EtherToken *EtherTokenSession) SwapEnabled() (bool, error) { 1791 return _EtherToken.Contract.SwapEnabled(&_EtherToken.CallOpts) 1792 } 1793 1794 // SwapEnabled is a free data retrieval call binding the contract method 0x6ddd1713. 1795 // 1796 // Solidity: function swapEnabled() constant returns(bool) 1797 func (_EtherToken *EtherTokenCallerSession) SwapEnabled() (bool, error) { 1798 return _EtherToken.Contract.SwapEnabled(&_EtherToken.CallOpts) 1799 } 1800 1801 // Token is a free data retrieval call binding the contract method 0xfc0c546a. 1802 // 1803 // Solidity: function token() constant returns(address) 1804 func (_EtherToken *EtherTokenCaller) Token(opts *bind.CallOpts) (common.Address, error) { 1805 var ( 1806 ret0 = new(common.Address) 1807 ) 1808 out := ret0 1809 err := _EtherToken.contract.Call(opts, out, "token") 1810 return *ret0, err 1811 } 1812 1813 // Token is a free data retrieval call binding the contract method 0xfc0c546a. 1814 // 1815 // Solidity: function token() constant returns(address) 1816 func (_EtherToken *EtherTokenSession) Token() (common.Address, error) { 1817 return _EtherToken.Contract.Token(&_EtherToken.CallOpts) 1818 } 1819 1820 // Token is a free data retrieval call binding the contract method 0xfc0c546a. 1821 // 1822 // Solidity: function token() constant returns(address) 1823 func (_EtherToken *EtherTokenCallerSession) Token() (common.Address, error) { 1824 return _EtherToken.Contract.Token(&_EtherToken.CallOpts) 1825 } 1826 1827 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1828 // 1829 // Solidity: function totalSupply() constant returns(uint256) 1830 func (_EtherToken *EtherTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 1831 var ( 1832 ret0 = new(*big.Int) 1833 ) 1834 out := ret0 1835 err := _EtherToken.contract.Call(opts, out, "totalSupply") 1836 return *ret0, err 1837 } 1838 1839 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1840 // 1841 // Solidity: function totalSupply() constant returns(uint256) 1842 func (_EtherToken *EtherTokenSession) TotalSupply() (*big.Int, error) { 1843 return _EtherToken.Contract.TotalSupply(&_EtherToken.CallOpts) 1844 } 1845 1846 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1847 // 1848 // Solidity: function totalSupply() constant returns(uint256) 1849 func (_EtherToken *EtherTokenCallerSession) TotalSupply() (*big.Int, error) { 1850 return _EtherToken.Contract.TotalSupply(&_EtherToken.CallOpts) 1851 } 1852 1853 // ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46. 1854 // 1855 // Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 1856 func (_EtherToken *EtherTokenTransactor) ApplyRequestInChildChain(opts *bind.TransactOpts, isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 1857 return _EtherToken.contract.Transact(opts, "applyRequestInChildChain", isExit, requestId, requestor, trieKey, trieValue) 1858 } 1859 1860 // ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46. 1861 // 1862 // Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 1863 func (_EtherToken *EtherTokenSession) ApplyRequestInChildChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 1864 return _EtherToken.Contract.ApplyRequestInChildChain(&_EtherToken.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 1865 } 1866 1867 // ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46. 1868 // 1869 // Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 1870 func (_EtherToken *EtherTokenTransactorSession) ApplyRequestInChildChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 1871 return _EtherToken.Contract.ApplyRequestInChildChain(&_EtherToken.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 1872 } 1873 1874 // ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308. 1875 // 1876 // Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 1877 func (_EtherToken *EtherTokenTransactor) ApplyRequestInRootChain(opts *bind.TransactOpts, isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 1878 return _EtherToken.contract.Transact(opts, "applyRequestInRootChain", isExit, requestId, requestor, trieKey, trieValue) 1879 } 1880 1881 // ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308. 1882 // 1883 // Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 1884 func (_EtherToken *EtherTokenSession) ApplyRequestInRootChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 1885 return _EtherToken.Contract.ApplyRequestInRootChain(&_EtherToken.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 1886 } 1887 1888 // ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308. 1889 // 1890 // Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 1891 func (_EtherToken *EtherTokenTransactorSession) ApplyRequestInRootChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 1892 return _EtherToken.Contract.ApplyRequestInRootChain(&_EtherToken.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 1893 } 1894 1895 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 1896 // 1897 // Solidity: function approve(address _spender, uint256 _value) returns(bool) 1898 func (_EtherToken *EtherTokenTransactor) Approve(opts *bind.TransactOpts, _spender common.Address, _value *big.Int) (*types.Transaction, error) { 1899 return _EtherToken.contract.Transact(opts, "approve", _spender, _value) 1900 } 1901 1902 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 1903 // 1904 // Solidity: function approve(address _spender, uint256 _value) returns(bool) 1905 func (_EtherToken *EtherTokenSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) { 1906 return _EtherToken.Contract.Approve(&_EtherToken.TransactOpts, _spender, _value) 1907 } 1908 1909 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 1910 // 1911 // Solidity: function approve(address _spender, uint256 _value) returns(bool) 1912 func (_EtherToken *EtherTokenTransactorSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) { 1913 return _EtherToken.Contract.Approve(&_EtherToken.TransactOpts, _spender, _value) 1914 } 1915 1916 // DecreaseApproval is a paid mutator transaction binding the contract method 0x66188463. 1917 // 1918 // Solidity: function decreaseApproval(address _spender, uint256 _subtractedValue) returns(bool) 1919 func (_EtherToken *EtherTokenTransactor) DecreaseApproval(opts *bind.TransactOpts, _spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error) { 1920 return _EtherToken.contract.Transact(opts, "decreaseApproval", _spender, _subtractedValue) 1921 } 1922 1923 // DecreaseApproval is a paid mutator transaction binding the contract method 0x66188463. 1924 // 1925 // Solidity: function decreaseApproval(address _spender, uint256 _subtractedValue) returns(bool) 1926 func (_EtherToken *EtherTokenSession) DecreaseApproval(_spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error) { 1927 return _EtherToken.Contract.DecreaseApproval(&_EtherToken.TransactOpts, _spender, _subtractedValue) 1928 } 1929 1930 // DecreaseApproval is a paid mutator transaction binding the contract method 0x66188463. 1931 // 1932 // Solidity: function decreaseApproval(address _spender, uint256 _subtractedValue) returns(bool) 1933 func (_EtherToken *EtherTokenTransactorSession) DecreaseApproval(_spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error) { 1934 return _EtherToken.Contract.DecreaseApproval(&_EtherToken.TransactOpts, _spender, _subtractedValue) 1935 } 1936 1937 // Deposit is a paid mutator transaction binding the contract method 0xb6b55f25. 1938 // 1939 // Solidity: function deposit(uint256 _amount) returns(bool) 1940 func (_EtherToken *EtherTokenTransactor) Deposit(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error) { 1941 return _EtherToken.contract.Transact(opts, "deposit", _amount) 1942 } 1943 1944 // Deposit is a paid mutator transaction binding the contract method 0xb6b55f25. 1945 // 1946 // Solidity: function deposit(uint256 _amount) returns(bool) 1947 func (_EtherToken *EtherTokenSession) Deposit(_amount *big.Int) (*types.Transaction, error) { 1948 return _EtherToken.Contract.Deposit(&_EtherToken.TransactOpts, _amount) 1949 } 1950 1951 // Deposit is a paid mutator transaction binding the contract method 0xb6b55f25. 1952 // 1953 // Solidity: function deposit(uint256 _amount) returns(bool) 1954 func (_EtherToken *EtherTokenTransactorSession) Deposit(_amount *big.Int) (*types.Transaction, error) { 1955 return _EtherToken.Contract.Deposit(&_EtherToken.TransactOpts, _amount) 1956 } 1957 1958 // IncreaseApproval is a paid mutator transaction binding the contract method 0xd73dd623. 1959 // 1960 // Solidity: function increaseApproval(address _spender, uint256 _addedValue) returns(bool) 1961 func (_EtherToken *EtherTokenTransactor) IncreaseApproval(opts *bind.TransactOpts, _spender common.Address, _addedValue *big.Int) (*types.Transaction, error) { 1962 return _EtherToken.contract.Transact(opts, "increaseApproval", _spender, _addedValue) 1963 } 1964 1965 // IncreaseApproval is a paid mutator transaction binding the contract method 0xd73dd623. 1966 // 1967 // Solidity: function increaseApproval(address _spender, uint256 _addedValue) returns(bool) 1968 func (_EtherToken *EtherTokenSession) IncreaseApproval(_spender common.Address, _addedValue *big.Int) (*types.Transaction, error) { 1969 return _EtherToken.Contract.IncreaseApproval(&_EtherToken.TransactOpts, _spender, _addedValue) 1970 } 1971 1972 // IncreaseApproval is a paid mutator transaction binding the contract method 0xd73dd623. 1973 // 1974 // Solidity: function increaseApproval(address _spender, uint256 _addedValue) returns(bool) 1975 func (_EtherToken *EtherTokenTransactorSession) IncreaseApproval(_spender common.Address, _addedValue *big.Int) (*types.Transaction, error) { 1976 return _EtherToken.Contract.IncreaseApproval(&_EtherToken.TransactOpts, _spender, _addedValue) 1977 } 1978 1979 // Init is a paid mutator transaction binding the contract method 0x19ab453c. 1980 // 1981 // Solidity: function init(address _rootchain) returns(bool) 1982 func (_EtherToken *EtherTokenTransactor) Init(opts *bind.TransactOpts, _rootchain common.Address) (*types.Transaction, error) { 1983 return _EtherToken.contract.Transact(opts, "init", _rootchain) 1984 } 1985 1986 // Init is a paid mutator transaction binding the contract method 0x19ab453c. 1987 // 1988 // Solidity: function init(address _rootchain) returns(bool) 1989 func (_EtherToken *EtherTokenSession) Init(_rootchain common.Address) (*types.Transaction, error) { 1990 return _EtherToken.Contract.Init(&_EtherToken.TransactOpts, _rootchain) 1991 } 1992 1993 // Init is a paid mutator transaction binding the contract method 0x19ab453c. 1994 // 1995 // Solidity: function init(address _rootchain) returns(bool) 1996 func (_EtherToken *EtherTokenTransactorSession) Init(_rootchain common.Address) (*types.Transaction, error) { 1997 return _EtherToken.Contract.Init(&_EtherToken.TransactOpts, _rootchain) 1998 } 1999 2000 // SwapFromEth is a paid mutator transaction binding the contract method 0x59310da7. 2001 // 2002 // Solidity: function swapFromEth() returns() 2003 func (_EtherToken *EtherTokenTransactor) SwapFromEth(opts *bind.TransactOpts) (*types.Transaction, error) { 2004 return _EtherToken.contract.Transact(opts, "swapFromEth") 2005 } 2006 2007 // SwapFromEth is a paid mutator transaction binding the contract method 0x59310da7. 2008 // 2009 // Solidity: function swapFromEth() returns() 2010 func (_EtherToken *EtherTokenSession) SwapFromEth() (*types.Transaction, error) { 2011 return _EtherToken.Contract.SwapFromEth(&_EtherToken.TransactOpts) 2012 } 2013 2014 // SwapFromEth is a paid mutator transaction binding the contract method 0x59310da7. 2015 // 2016 // Solidity: function swapFromEth() returns() 2017 func (_EtherToken *EtherTokenTransactorSession) SwapFromEth() (*types.Transaction, error) { 2018 return _EtherToken.Contract.SwapFromEth(&_EtherToken.TransactOpts) 2019 } 2020 2021 // SwapToEth is a paid mutator transaction binding the contract method 0xb06c6729. 2022 // 2023 // Solidity: function swapToEth(uint256 _amount) returns() 2024 func (_EtherToken *EtherTokenTransactor) SwapToEth(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error) { 2025 return _EtherToken.contract.Transact(opts, "swapToEth", _amount) 2026 } 2027 2028 // SwapToEth is a paid mutator transaction binding the contract method 0xb06c6729. 2029 // 2030 // Solidity: function swapToEth(uint256 _amount) returns() 2031 func (_EtherToken *EtherTokenSession) SwapToEth(_amount *big.Int) (*types.Transaction, error) { 2032 return _EtherToken.Contract.SwapToEth(&_EtherToken.TransactOpts, _amount) 2033 } 2034 2035 // SwapToEth is a paid mutator transaction binding the contract method 0xb06c6729. 2036 // 2037 // Solidity: function swapToEth(uint256 _amount) returns() 2038 func (_EtherToken *EtherTokenTransactorSession) SwapToEth(_amount *big.Int) (*types.Transaction, error) { 2039 return _EtherToken.Contract.SwapToEth(&_EtherToken.TransactOpts, _amount) 2040 } 2041 2042 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 2043 // 2044 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 2045 func (_EtherToken *EtherTokenTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error) { 2046 return _EtherToken.contract.Transact(opts, "transfer", _to, _value) 2047 } 2048 2049 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 2050 // 2051 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 2052 func (_EtherToken *EtherTokenSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { 2053 return _EtherToken.Contract.Transfer(&_EtherToken.TransactOpts, _to, _value) 2054 } 2055 2056 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 2057 // 2058 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 2059 func (_EtherToken *EtherTokenTransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { 2060 return _EtherToken.Contract.Transfer(&_EtherToken.TransactOpts, _to, _value) 2061 } 2062 2063 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 2064 // 2065 // Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool) 2066 func (_EtherToken *EtherTokenTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { 2067 return _EtherToken.contract.Transact(opts, "transferFrom", _from, _to, _value) 2068 } 2069 2070 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 2071 // 2072 // Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool) 2073 func (_EtherToken *EtherTokenSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { 2074 return _EtherToken.Contract.TransferFrom(&_EtherToken.TransactOpts, _from, _to, _value) 2075 } 2076 2077 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 2078 // 2079 // Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool) 2080 func (_EtherToken *EtherTokenTransactorSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { 2081 return _EtherToken.Contract.TransferFrom(&_EtherToken.TransactOpts, _from, _to, _value) 2082 } 2083 2084 // Withdraw is a paid mutator transaction binding the contract method 0x2e1a7d4d. 2085 // 2086 // Solidity: function withdraw(uint256 _amount) returns(bool) 2087 func (_EtherToken *EtherTokenTransactor) Withdraw(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error) { 2088 return _EtherToken.contract.Transact(opts, "withdraw", _amount) 2089 } 2090 2091 // Withdraw is a paid mutator transaction binding the contract method 0x2e1a7d4d. 2092 // 2093 // Solidity: function withdraw(uint256 _amount) returns(bool) 2094 func (_EtherToken *EtherTokenSession) Withdraw(_amount *big.Int) (*types.Transaction, error) { 2095 return _EtherToken.Contract.Withdraw(&_EtherToken.TransactOpts, _amount) 2096 } 2097 2098 // Withdraw is a paid mutator transaction binding the contract method 0x2e1a7d4d. 2099 // 2100 // Solidity: function withdraw(uint256 _amount) returns(bool) 2101 func (_EtherToken *EtherTokenTransactorSession) Withdraw(_amount *big.Int) (*types.Transaction, error) { 2102 return _EtherToken.Contract.Withdraw(&_EtherToken.TransactOpts, _amount) 2103 } 2104 2105 // EtherTokenApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the EtherToken contract. 2106 type EtherTokenApprovalIterator struct { 2107 Event *EtherTokenApproval // Event containing the contract specifics and raw log 2108 2109 contract *bind.BoundContract // Generic contract to use for unpacking event data 2110 event string // Event name to use for unpacking event data 2111 2112 logs chan types.Log // Log channel receiving the found contract events 2113 sub ethereum.Subscription // Subscription for errors, completion and termination 2114 done bool // Whether the subscription completed delivering logs 2115 fail error // Occurred error to stop iteration 2116 } 2117 2118 // Next advances the iterator to the subsequent event, returning whether there 2119 // are any more events found. In case of a retrieval or parsing error, false is 2120 // returned and Error() can be queried for the exact failure. 2121 func (it *EtherTokenApprovalIterator) Next() bool { 2122 // If the iterator failed, stop iterating 2123 if it.fail != nil { 2124 return false 2125 } 2126 // If the iterator completed, deliver directly whatever's available 2127 if it.done { 2128 select { 2129 case log := <-it.logs: 2130 it.Event = new(EtherTokenApproval) 2131 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2132 it.fail = err 2133 return false 2134 } 2135 it.Event.Raw = log 2136 return true 2137 2138 default: 2139 return false 2140 } 2141 } 2142 // Iterator still in progress, wait for either a data or an error event 2143 select { 2144 case log := <-it.logs: 2145 it.Event = new(EtherTokenApproval) 2146 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2147 it.fail = err 2148 return false 2149 } 2150 it.Event.Raw = log 2151 return true 2152 2153 case err := <-it.sub.Err(): 2154 it.done = true 2155 it.fail = err 2156 return it.Next() 2157 } 2158 } 2159 2160 // Error returns any retrieval or parsing error occurred during filtering. 2161 func (it *EtherTokenApprovalIterator) Error() error { 2162 return it.fail 2163 } 2164 2165 // Close terminates the iteration process, releasing any pending underlying 2166 // resources. 2167 func (it *EtherTokenApprovalIterator) Close() error { 2168 it.sub.Unsubscribe() 2169 return nil 2170 } 2171 2172 // EtherTokenApproval represents a Approval event raised by the EtherToken contract. 2173 type EtherTokenApproval struct { 2174 Owner common.Address 2175 Spender common.Address 2176 Value *big.Int 2177 Raw types.Log // Blockchain specific contextual infos 2178 } 2179 2180 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 2181 // 2182 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 2183 func (_EtherToken *EtherTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*EtherTokenApprovalIterator, error) { 2184 2185 var ownerRule []interface{} 2186 for _, ownerItem := range owner { 2187 ownerRule = append(ownerRule, ownerItem) 2188 } 2189 var spenderRule []interface{} 2190 for _, spenderItem := range spender { 2191 spenderRule = append(spenderRule, spenderItem) 2192 } 2193 2194 logs, sub, err := _EtherToken.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 2195 if err != nil { 2196 return nil, err 2197 } 2198 return &EtherTokenApprovalIterator{contract: _EtherToken.contract, event: "Approval", logs: logs, sub: sub}, nil 2199 } 2200 2201 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 2202 // 2203 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 2204 func (_EtherToken *EtherTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *EtherTokenApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 2205 2206 var ownerRule []interface{} 2207 for _, ownerItem := range owner { 2208 ownerRule = append(ownerRule, ownerItem) 2209 } 2210 var spenderRule []interface{} 2211 for _, spenderItem := range spender { 2212 spenderRule = append(spenderRule, spenderItem) 2213 } 2214 2215 logs, sub, err := _EtherToken.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 2216 if err != nil { 2217 return nil, err 2218 } 2219 return event.NewSubscription(func(quit <-chan struct{}) error { 2220 defer sub.Unsubscribe() 2221 for { 2222 select { 2223 case log := <-logs: 2224 // New log arrived, parse the event and forward to the user 2225 event := new(EtherTokenApproval) 2226 if err := _EtherToken.contract.UnpackLog(event, "Approval", log); err != nil { 2227 return err 2228 } 2229 event.Raw = log 2230 2231 select { 2232 case sink <- event: 2233 case err := <-sub.Err(): 2234 return err 2235 case <-quit: 2236 return nil 2237 } 2238 case err := <-sub.Err(): 2239 return err 2240 case <-quit: 2241 return nil 2242 } 2243 } 2244 }), nil 2245 } 2246 2247 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 2248 // 2249 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 2250 func (_EtherToken *EtherTokenFilterer) ParseApproval(log types.Log) (*EtherTokenApproval, error) { 2251 event := new(EtherTokenApproval) 2252 if err := _EtherToken.contract.UnpackLog(event, "Approval", log); err != nil { 2253 return nil, err 2254 } 2255 return event, nil 2256 } 2257 2258 // EtherTokenDeposittedIterator is returned from FilterDepositted and is used to iterate over the raw logs and unpacked data for Depositted events raised by the EtherToken contract. 2259 type EtherTokenDeposittedIterator struct { 2260 Event *EtherTokenDepositted // Event containing the contract specifics and raw log 2261 2262 contract *bind.BoundContract // Generic contract to use for unpacking event data 2263 event string // Event name to use for unpacking event data 2264 2265 logs chan types.Log // Log channel receiving the found contract events 2266 sub ethereum.Subscription // Subscription for errors, completion and termination 2267 done bool // Whether the subscription completed delivering logs 2268 fail error // Occurred error to stop iteration 2269 } 2270 2271 // Next advances the iterator to the subsequent event, returning whether there 2272 // are any more events found. In case of a retrieval or parsing error, false is 2273 // returned and Error() can be queried for the exact failure. 2274 func (it *EtherTokenDeposittedIterator) Next() bool { 2275 // If the iterator failed, stop iterating 2276 if it.fail != nil { 2277 return false 2278 } 2279 // If the iterator completed, deliver directly whatever's available 2280 if it.done { 2281 select { 2282 case log := <-it.logs: 2283 it.Event = new(EtherTokenDepositted) 2284 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2285 it.fail = err 2286 return false 2287 } 2288 it.Event.Raw = log 2289 return true 2290 2291 default: 2292 return false 2293 } 2294 } 2295 // Iterator still in progress, wait for either a data or an error event 2296 select { 2297 case log := <-it.logs: 2298 it.Event = new(EtherTokenDepositted) 2299 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2300 it.fail = err 2301 return false 2302 } 2303 it.Event.Raw = log 2304 return true 2305 2306 case err := <-it.sub.Err(): 2307 it.done = true 2308 it.fail = err 2309 return it.Next() 2310 } 2311 } 2312 2313 // Error returns any retrieval or parsing error occurred during filtering. 2314 func (it *EtherTokenDeposittedIterator) Error() error { 2315 return it.fail 2316 } 2317 2318 // Close terminates the iteration process, releasing any pending underlying 2319 // resources. 2320 func (it *EtherTokenDeposittedIterator) Close() error { 2321 it.sub.Unsubscribe() 2322 return nil 2323 } 2324 2325 // EtherTokenDepositted represents a Depositted event raised by the EtherToken contract. 2326 type EtherTokenDepositted struct { 2327 From common.Address 2328 Value *big.Int 2329 Raw types.Log // Blockchain specific contextual infos 2330 } 2331 2332 // FilterDepositted is a free log retrieval operation binding the contract event 0x46fc0825df492a7a7f1fb1b690f6912ecb69575484fbb24be0f398ae70d97db4. 2333 // 2334 // Solidity: event Depositted(address _from, uint256 _value) 2335 func (_EtherToken *EtherTokenFilterer) FilterDepositted(opts *bind.FilterOpts) (*EtherTokenDeposittedIterator, error) { 2336 2337 logs, sub, err := _EtherToken.contract.FilterLogs(opts, "Depositted") 2338 if err != nil { 2339 return nil, err 2340 } 2341 return &EtherTokenDeposittedIterator{contract: _EtherToken.contract, event: "Depositted", logs: logs, sub: sub}, nil 2342 } 2343 2344 // WatchDepositted is a free log subscription operation binding the contract event 0x46fc0825df492a7a7f1fb1b690f6912ecb69575484fbb24be0f398ae70d97db4. 2345 // 2346 // Solidity: event Depositted(address _from, uint256 _value) 2347 func (_EtherToken *EtherTokenFilterer) WatchDepositted(opts *bind.WatchOpts, sink chan<- *EtherTokenDepositted) (event.Subscription, error) { 2348 2349 logs, sub, err := _EtherToken.contract.WatchLogs(opts, "Depositted") 2350 if err != nil { 2351 return nil, err 2352 } 2353 return event.NewSubscription(func(quit <-chan struct{}) error { 2354 defer sub.Unsubscribe() 2355 for { 2356 select { 2357 case log := <-logs: 2358 // New log arrived, parse the event and forward to the user 2359 event := new(EtherTokenDepositted) 2360 if err := _EtherToken.contract.UnpackLog(event, "Depositted", log); err != nil { 2361 return err 2362 } 2363 event.Raw = log 2364 2365 select { 2366 case sink <- event: 2367 case err := <-sub.Err(): 2368 return err 2369 case <-quit: 2370 return nil 2371 } 2372 case err := <-sub.Err(): 2373 return err 2374 case <-quit: 2375 return nil 2376 } 2377 } 2378 }), nil 2379 } 2380 2381 // ParseDepositted is a log parse operation binding the contract event 0x46fc0825df492a7a7f1fb1b690f6912ecb69575484fbb24be0f398ae70d97db4. 2382 // 2383 // Solidity: event Depositted(address _from, uint256 _value) 2384 func (_EtherToken *EtherTokenFilterer) ParseDepositted(log types.Log) (*EtherTokenDepositted, error) { 2385 event := new(EtherTokenDepositted) 2386 if err := _EtherToken.contract.UnpackLog(event, "Depositted", log); err != nil { 2387 return nil, err 2388 } 2389 return event, nil 2390 } 2391 2392 // EtherTokenRequestCreatedIterator is returned from FilterRequestCreated and is used to iterate over the raw logs and unpacked data for RequestCreated events raised by the EtherToken contract. 2393 type EtherTokenRequestCreatedIterator struct { 2394 Event *EtherTokenRequestCreated // Event containing the contract specifics and raw log 2395 2396 contract *bind.BoundContract // Generic contract to use for unpacking event data 2397 event string // Event name to use for unpacking event data 2398 2399 logs chan types.Log // Log channel receiving the found contract events 2400 sub ethereum.Subscription // Subscription for errors, completion and termination 2401 done bool // Whether the subscription completed delivering logs 2402 fail error // Occurred error to stop iteration 2403 } 2404 2405 // Next advances the iterator to the subsequent event, returning whether there 2406 // are any more events found. In case of a retrieval or parsing error, false is 2407 // returned and Error() can be queried for the exact failure. 2408 func (it *EtherTokenRequestCreatedIterator) Next() bool { 2409 // If the iterator failed, stop iterating 2410 if it.fail != nil { 2411 return false 2412 } 2413 // If the iterator completed, deliver directly whatever's available 2414 if it.done { 2415 select { 2416 case log := <-it.logs: 2417 it.Event = new(EtherTokenRequestCreated) 2418 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2419 it.fail = err 2420 return false 2421 } 2422 it.Event.Raw = log 2423 return true 2424 2425 default: 2426 return false 2427 } 2428 } 2429 // Iterator still in progress, wait for either a data or an error event 2430 select { 2431 case log := <-it.logs: 2432 it.Event = new(EtherTokenRequestCreated) 2433 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2434 it.fail = err 2435 return false 2436 } 2437 it.Event.Raw = log 2438 return true 2439 2440 case err := <-it.sub.Err(): 2441 it.done = true 2442 it.fail = err 2443 return it.Next() 2444 } 2445 } 2446 2447 // Error returns any retrieval or parsing error occurred during filtering. 2448 func (it *EtherTokenRequestCreatedIterator) Error() error { 2449 return it.fail 2450 } 2451 2452 // Close terminates the iteration process, releasing any pending underlying 2453 // resources. 2454 func (it *EtherTokenRequestCreatedIterator) Close() error { 2455 it.sub.Unsubscribe() 2456 return nil 2457 } 2458 2459 // EtherTokenRequestCreated represents a RequestCreated event raised by the EtherToken contract. 2460 type EtherTokenRequestCreated struct { 2461 IsExit bool 2462 Requestor common.Address 2463 TrieKey [32]byte 2464 Value *big.Int 2465 Raw types.Log // Blockchain specific contextual infos 2466 } 2467 2468 // FilterRequestCreated is a free log retrieval operation binding the contract event 0x4b0c23cd90bac23cdaa0958fbd0306f53e20cd5e65676d21b9ceb109784e15b8. 2469 // 2470 // Solidity: event RequestCreated(bool _isExit, address _requestor, bytes32 _trieKey, uint256 _value) 2471 func (_EtherToken *EtherTokenFilterer) FilterRequestCreated(opts *bind.FilterOpts) (*EtherTokenRequestCreatedIterator, error) { 2472 2473 logs, sub, err := _EtherToken.contract.FilterLogs(opts, "RequestCreated") 2474 if err != nil { 2475 return nil, err 2476 } 2477 return &EtherTokenRequestCreatedIterator{contract: _EtherToken.contract, event: "RequestCreated", logs: logs, sub: sub}, nil 2478 } 2479 2480 // WatchRequestCreated is a free log subscription operation binding the contract event 0x4b0c23cd90bac23cdaa0958fbd0306f53e20cd5e65676d21b9ceb109784e15b8. 2481 // 2482 // Solidity: event RequestCreated(bool _isExit, address _requestor, bytes32 _trieKey, uint256 _value) 2483 func (_EtherToken *EtherTokenFilterer) WatchRequestCreated(opts *bind.WatchOpts, sink chan<- *EtherTokenRequestCreated) (event.Subscription, error) { 2484 2485 logs, sub, err := _EtherToken.contract.WatchLogs(opts, "RequestCreated") 2486 if err != nil { 2487 return nil, err 2488 } 2489 return event.NewSubscription(func(quit <-chan struct{}) error { 2490 defer sub.Unsubscribe() 2491 for { 2492 select { 2493 case log := <-logs: 2494 // New log arrived, parse the event and forward to the user 2495 event := new(EtherTokenRequestCreated) 2496 if err := _EtherToken.contract.UnpackLog(event, "RequestCreated", log); err != nil { 2497 return err 2498 } 2499 event.Raw = log 2500 2501 select { 2502 case sink <- event: 2503 case err := <-sub.Err(): 2504 return err 2505 case <-quit: 2506 return nil 2507 } 2508 case err := <-sub.Err(): 2509 return err 2510 case <-quit: 2511 return nil 2512 } 2513 } 2514 }), nil 2515 } 2516 2517 // ParseRequestCreated is a log parse operation binding the contract event 0x4b0c23cd90bac23cdaa0958fbd0306f53e20cd5e65676d21b9ceb109784e15b8. 2518 // 2519 // Solidity: event RequestCreated(bool _isExit, address _requestor, bytes32 _trieKey, uint256 _value) 2520 func (_EtherToken *EtherTokenFilterer) ParseRequestCreated(log types.Log) (*EtherTokenRequestCreated, error) { 2521 event := new(EtherTokenRequestCreated) 2522 if err := _EtherToken.contract.UnpackLog(event, "RequestCreated", log); err != nil { 2523 return nil, err 2524 } 2525 return event, nil 2526 } 2527 2528 // EtherTokenTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the EtherToken contract. 2529 type EtherTokenTransferIterator struct { 2530 Event *EtherTokenTransfer // Event containing the contract specifics and raw log 2531 2532 contract *bind.BoundContract // Generic contract to use for unpacking event data 2533 event string // Event name to use for unpacking event data 2534 2535 logs chan types.Log // Log channel receiving the found contract events 2536 sub ethereum.Subscription // Subscription for errors, completion and termination 2537 done bool // Whether the subscription completed delivering logs 2538 fail error // Occurred error to stop iteration 2539 } 2540 2541 // Next advances the iterator to the subsequent event, returning whether there 2542 // are any more events found. In case of a retrieval or parsing error, false is 2543 // returned and Error() can be queried for the exact failure. 2544 func (it *EtherTokenTransferIterator) Next() bool { 2545 // If the iterator failed, stop iterating 2546 if it.fail != nil { 2547 return false 2548 } 2549 // If the iterator completed, deliver directly whatever's available 2550 if it.done { 2551 select { 2552 case log := <-it.logs: 2553 it.Event = new(EtherTokenTransfer) 2554 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2555 it.fail = err 2556 return false 2557 } 2558 it.Event.Raw = log 2559 return true 2560 2561 default: 2562 return false 2563 } 2564 } 2565 // Iterator still in progress, wait for either a data or an error event 2566 select { 2567 case log := <-it.logs: 2568 it.Event = new(EtherTokenTransfer) 2569 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2570 it.fail = err 2571 return false 2572 } 2573 it.Event.Raw = log 2574 return true 2575 2576 case err := <-it.sub.Err(): 2577 it.done = true 2578 it.fail = err 2579 return it.Next() 2580 } 2581 } 2582 2583 // Error returns any retrieval or parsing error occurred during filtering. 2584 func (it *EtherTokenTransferIterator) Error() error { 2585 return it.fail 2586 } 2587 2588 // Close terminates the iteration process, releasing any pending underlying 2589 // resources. 2590 func (it *EtherTokenTransferIterator) Close() error { 2591 it.sub.Unsubscribe() 2592 return nil 2593 } 2594 2595 // EtherTokenTransfer represents a Transfer event raised by the EtherToken contract. 2596 type EtherTokenTransfer struct { 2597 From common.Address 2598 To common.Address 2599 Value *big.Int 2600 Raw types.Log // Blockchain specific contextual infos 2601 } 2602 2603 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 2604 // 2605 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 2606 func (_EtherToken *EtherTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*EtherTokenTransferIterator, error) { 2607 2608 var fromRule []interface{} 2609 for _, fromItem := range from { 2610 fromRule = append(fromRule, fromItem) 2611 } 2612 var toRule []interface{} 2613 for _, toItem := range to { 2614 toRule = append(toRule, toItem) 2615 } 2616 2617 logs, sub, err := _EtherToken.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 2618 if err != nil { 2619 return nil, err 2620 } 2621 return &EtherTokenTransferIterator{contract: _EtherToken.contract, event: "Transfer", logs: logs, sub: sub}, nil 2622 } 2623 2624 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 2625 // 2626 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 2627 func (_EtherToken *EtherTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *EtherTokenTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 2628 2629 var fromRule []interface{} 2630 for _, fromItem := range from { 2631 fromRule = append(fromRule, fromItem) 2632 } 2633 var toRule []interface{} 2634 for _, toItem := range to { 2635 toRule = append(toRule, toItem) 2636 } 2637 2638 logs, sub, err := _EtherToken.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 2639 if err != nil { 2640 return nil, err 2641 } 2642 return event.NewSubscription(func(quit <-chan struct{}) error { 2643 defer sub.Unsubscribe() 2644 for { 2645 select { 2646 case log := <-logs: 2647 // New log arrived, parse the event and forward to the user 2648 event := new(EtherTokenTransfer) 2649 if err := _EtherToken.contract.UnpackLog(event, "Transfer", log); err != nil { 2650 return err 2651 } 2652 event.Raw = log 2653 2654 select { 2655 case sink <- event: 2656 case err := <-sub.Err(): 2657 return err 2658 case <-quit: 2659 return nil 2660 } 2661 case err := <-sub.Err(): 2662 return err 2663 case <-quit: 2664 return nil 2665 } 2666 } 2667 }), nil 2668 } 2669 2670 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 2671 // 2672 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 2673 func (_EtherToken *EtherTokenFilterer) ParseTransfer(log types.Log) (*EtherTokenTransfer, error) { 2674 event := new(EtherTokenTransfer) 2675 if err := _EtherToken.contract.UnpackLog(event, "Transfer", log); err != nil { 2676 return nil, err 2677 } 2678 return event, nil 2679 } 2680 2681 // EtherTokenWithdrawnIterator is returned from FilterWithdrawn and is used to iterate over the raw logs and unpacked data for Withdrawn events raised by the EtherToken contract. 2682 type EtherTokenWithdrawnIterator struct { 2683 Event *EtherTokenWithdrawn // Event containing the contract specifics and raw log 2684 2685 contract *bind.BoundContract // Generic contract to use for unpacking event data 2686 event string // Event name to use for unpacking event data 2687 2688 logs chan types.Log // Log channel receiving the found contract events 2689 sub ethereum.Subscription // Subscription for errors, completion and termination 2690 done bool // Whether the subscription completed delivering logs 2691 fail error // Occurred error to stop iteration 2692 } 2693 2694 // Next advances the iterator to the subsequent event, returning whether there 2695 // are any more events found. In case of a retrieval or parsing error, false is 2696 // returned and Error() can be queried for the exact failure. 2697 func (it *EtherTokenWithdrawnIterator) Next() bool { 2698 // If the iterator failed, stop iterating 2699 if it.fail != nil { 2700 return false 2701 } 2702 // If the iterator completed, deliver directly whatever's available 2703 if it.done { 2704 select { 2705 case log := <-it.logs: 2706 it.Event = new(EtherTokenWithdrawn) 2707 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2708 it.fail = err 2709 return false 2710 } 2711 it.Event.Raw = log 2712 return true 2713 2714 default: 2715 return false 2716 } 2717 } 2718 // Iterator still in progress, wait for either a data or an error event 2719 select { 2720 case log := <-it.logs: 2721 it.Event = new(EtherTokenWithdrawn) 2722 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2723 it.fail = err 2724 return false 2725 } 2726 it.Event.Raw = log 2727 return true 2728 2729 case err := <-it.sub.Err(): 2730 it.done = true 2731 it.fail = err 2732 return it.Next() 2733 } 2734 } 2735 2736 // Error returns any retrieval or parsing error occurred during filtering. 2737 func (it *EtherTokenWithdrawnIterator) Error() error { 2738 return it.fail 2739 } 2740 2741 // Close terminates the iteration process, releasing any pending underlying 2742 // resources. 2743 func (it *EtherTokenWithdrawnIterator) Close() error { 2744 it.sub.Unsubscribe() 2745 return nil 2746 } 2747 2748 // EtherTokenWithdrawn represents a Withdrawn event raised by the EtherToken contract. 2749 type EtherTokenWithdrawn struct { 2750 From common.Address 2751 Value *big.Int 2752 Raw types.Log // Blockchain specific contextual infos 2753 } 2754 2755 // FilterWithdrawn is a free log retrieval operation binding the contract event 0x7084f5476618d8e60b11ef0d7d3f06914655adb8793e28ff7f018d4c76d505d5. 2756 // 2757 // Solidity: event Withdrawn(address _from, uint256 _value) 2758 func (_EtherToken *EtherTokenFilterer) FilterWithdrawn(opts *bind.FilterOpts) (*EtherTokenWithdrawnIterator, error) { 2759 2760 logs, sub, err := _EtherToken.contract.FilterLogs(opts, "Withdrawn") 2761 if err != nil { 2762 return nil, err 2763 } 2764 return &EtherTokenWithdrawnIterator{contract: _EtherToken.contract, event: "Withdrawn", logs: logs, sub: sub}, nil 2765 } 2766 2767 // WatchWithdrawn is a free log subscription operation binding the contract event 0x7084f5476618d8e60b11ef0d7d3f06914655adb8793e28ff7f018d4c76d505d5. 2768 // 2769 // Solidity: event Withdrawn(address _from, uint256 _value) 2770 func (_EtherToken *EtherTokenFilterer) WatchWithdrawn(opts *bind.WatchOpts, sink chan<- *EtherTokenWithdrawn) (event.Subscription, error) { 2771 2772 logs, sub, err := _EtherToken.contract.WatchLogs(opts, "Withdrawn") 2773 if err != nil { 2774 return nil, err 2775 } 2776 return event.NewSubscription(func(quit <-chan struct{}) error { 2777 defer sub.Unsubscribe() 2778 for { 2779 select { 2780 case log := <-logs: 2781 // New log arrived, parse the event and forward to the user 2782 event := new(EtherTokenWithdrawn) 2783 if err := _EtherToken.contract.UnpackLog(event, "Withdrawn", log); err != nil { 2784 return err 2785 } 2786 event.Raw = log 2787 2788 select { 2789 case sink <- event: 2790 case err := <-sub.Err(): 2791 return err 2792 case <-quit: 2793 return nil 2794 } 2795 case err := <-sub.Err(): 2796 return err 2797 case <-quit: 2798 return nil 2799 } 2800 } 2801 }), nil 2802 } 2803 2804 // ParseWithdrawn is a log parse operation binding the contract event 0x7084f5476618d8e60b11ef0d7d3f06914655adb8793e28ff7f018d4c76d505d5. 2805 // 2806 // Solidity: event Withdrawn(address _from, uint256 _value) 2807 func (_EtherToken *EtherTokenFilterer) ParseWithdrawn(log types.Log) (*EtherTokenWithdrawn, error) { 2808 event := new(EtherTokenWithdrawn) 2809 if err := _EtherToken.contract.UnpackLog(event, "Withdrawn", log); err != nil { 2810 return nil, err 2811 } 2812 return event, nil 2813 } 2814 2815 // RequestableERC20WrapperABI is the input ABI used to generate the binding from. 2816 const RequestableERC20WrapperABI = "[{\"inputs\":[{\"internalType\":\"bool\",\"name\":\"_development\",\"type\":\"bool\"},{\"internalType\":\"contractERC20\",\"name\":\"_token\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"Depositted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"_isExit\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_requestor\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"_trieKey\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"RequestCreated\",\"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\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"Withdrawn\",\"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\":\"bool\",\"name\":\"isExit\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"requestId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"requestor\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"trieKey\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"trieValue\",\"type\":\"bytes\"}],\"name\":\"applyRequestInChildChain\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"isExit\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"requestId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"requestor\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"trieKey\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"trieValue\",\"type\":\"bytes\"}],\"name\":\"applyRequestInRootChain\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"trieValue\",\"type\":\"bytes\"}],\"name\":\"decodeTrieValue\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"v\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseApproval\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"development\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_who\",\"type\":\"address\"}],\"name\":\"getBalanceTrieKey\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseApproval\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_rootchain\",\"type\":\"address\"}],\"name\":\"init\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"initialized\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"rootchain\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"token\",\"outputs\":[{\"internalType\":\"contractERC20\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_amount\",\"type\":\"uint256\"}],\"name\":\"withdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 2817 2818 // RequestableERC20WrapperFuncSigs maps the 4-byte function signature to its string representation. 2819 var RequestableERC20WrapperFuncSigs = map[string]string{ 2820 "dd62ed3e": "allowance(address,address)", 2821 "141ecf46": "applyRequestInChildChain(bool,uint256,address,bytes32,bytes)", 2822 "a9f79308": "applyRequestInRootChain(bool,uint256,address,bytes32,bytes)", 2823 "095ea7b3": "approve(address,uint256)", 2824 "70a08231": "balanceOf(address)", 2825 "b9e59d09": "decodeTrieValue(bytes)", 2826 "66188463": "decreaseApproval(address,uint256)", 2827 "b6b55f25": "deposit(uint256)", 2828 "7b929c27": "development()", 2829 "b18fcfdf": "getBalanceTrieKey(address)", 2830 "d73dd623": "increaseApproval(address,uint256)", 2831 "19ab453c": "init(address)", 2832 "158ef93e": "initialized()", 2833 "bcc7874d": "rootchain()", 2834 "fc0c546a": "token()", 2835 "18160ddd": "totalSupply()", 2836 "a9059cbb": "transfer(address,uint256)", 2837 "23b872dd": "transferFrom(address,address,uint256)", 2838 "2e1a7d4d": "withdraw(uint256)", 2839 } 2840 2841 // RequestableERC20WrapperBin is the compiled bytecode used for deploying new contracts. 2842 var RequestableERC20WrapperBin = "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" 2843 2844 // DeployRequestableERC20Wrapper deploys a new Ethereum contract, binding an instance of RequestableERC20Wrapper to it. 2845 func DeployRequestableERC20Wrapper(auth *bind.TransactOpts, backend bind.ContractBackend, _development bool, _token common.Address) (common.Address, *types.Transaction, *RequestableERC20Wrapper, error) { 2846 parsed, err := abi.JSON(strings.NewReader(RequestableERC20WrapperABI)) 2847 if err != nil { 2848 return common.Address{}, nil, nil, err 2849 } 2850 2851 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(RequestableERC20WrapperBin), backend, _development, _token) 2852 if err != nil { 2853 return common.Address{}, nil, nil, err 2854 } 2855 return address, tx, &RequestableERC20Wrapper{RequestableERC20WrapperCaller: RequestableERC20WrapperCaller{contract: contract}, RequestableERC20WrapperTransactor: RequestableERC20WrapperTransactor{contract: contract}, RequestableERC20WrapperFilterer: RequestableERC20WrapperFilterer{contract: contract}}, nil 2856 } 2857 2858 // RequestableERC20Wrapper is an auto generated Go binding around an Ethereum contract. 2859 type RequestableERC20Wrapper struct { 2860 RequestableERC20WrapperCaller // Read-only binding to the contract 2861 RequestableERC20WrapperTransactor // Write-only binding to the contract 2862 RequestableERC20WrapperFilterer // Log filterer for contract events 2863 } 2864 2865 // RequestableERC20WrapperCaller is an auto generated read-only Go binding around an Ethereum contract. 2866 type RequestableERC20WrapperCaller struct { 2867 contract *bind.BoundContract // Generic contract wrapper for the low level calls 2868 } 2869 2870 // RequestableERC20WrapperTransactor is an auto generated write-only Go binding around an Ethereum contract. 2871 type RequestableERC20WrapperTransactor struct { 2872 contract *bind.BoundContract // Generic contract wrapper for the low level calls 2873 } 2874 2875 // RequestableERC20WrapperFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 2876 type RequestableERC20WrapperFilterer struct { 2877 contract *bind.BoundContract // Generic contract wrapper for the low level calls 2878 } 2879 2880 // RequestableERC20WrapperSession is an auto generated Go binding around an Ethereum contract, 2881 // with pre-set call and transact options. 2882 type RequestableERC20WrapperSession struct { 2883 Contract *RequestableERC20Wrapper // Generic contract binding to set the session for 2884 CallOpts bind.CallOpts // Call options to use throughout this session 2885 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 2886 } 2887 2888 // RequestableERC20WrapperCallerSession is an auto generated read-only Go binding around an Ethereum contract, 2889 // with pre-set call options. 2890 type RequestableERC20WrapperCallerSession struct { 2891 Contract *RequestableERC20WrapperCaller // Generic contract caller binding to set the session for 2892 CallOpts bind.CallOpts // Call options to use throughout this session 2893 } 2894 2895 // RequestableERC20WrapperTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 2896 // with pre-set transact options. 2897 type RequestableERC20WrapperTransactorSession struct { 2898 Contract *RequestableERC20WrapperTransactor // Generic contract transactor binding to set the session for 2899 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 2900 } 2901 2902 // RequestableERC20WrapperRaw is an auto generated low-level Go binding around an Ethereum contract. 2903 type RequestableERC20WrapperRaw struct { 2904 Contract *RequestableERC20Wrapper // Generic contract binding to access the raw methods on 2905 } 2906 2907 // RequestableERC20WrapperCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 2908 type RequestableERC20WrapperCallerRaw struct { 2909 Contract *RequestableERC20WrapperCaller // Generic read-only contract binding to access the raw methods on 2910 } 2911 2912 // RequestableERC20WrapperTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 2913 type RequestableERC20WrapperTransactorRaw struct { 2914 Contract *RequestableERC20WrapperTransactor // Generic write-only contract binding to access the raw methods on 2915 } 2916 2917 // NewRequestableERC20Wrapper creates a new instance of RequestableERC20Wrapper, bound to a specific deployed contract. 2918 func NewRequestableERC20Wrapper(address common.Address, backend bind.ContractBackend) (*RequestableERC20Wrapper, error) { 2919 contract, err := bindRequestableERC20Wrapper(address, backend, backend, backend) 2920 if err != nil { 2921 return nil, err 2922 } 2923 return &RequestableERC20Wrapper{RequestableERC20WrapperCaller: RequestableERC20WrapperCaller{contract: contract}, RequestableERC20WrapperTransactor: RequestableERC20WrapperTransactor{contract: contract}, RequestableERC20WrapperFilterer: RequestableERC20WrapperFilterer{contract: contract}}, nil 2924 } 2925 2926 // NewRequestableERC20WrapperCaller creates a new read-only instance of RequestableERC20Wrapper, bound to a specific deployed contract. 2927 func NewRequestableERC20WrapperCaller(address common.Address, caller bind.ContractCaller) (*RequestableERC20WrapperCaller, error) { 2928 contract, err := bindRequestableERC20Wrapper(address, caller, nil, nil) 2929 if err != nil { 2930 return nil, err 2931 } 2932 return &RequestableERC20WrapperCaller{contract: contract}, nil 2933 } 2934 2935 // NewRequestableERC20WrapperTransactor creates a new write-only instance of RequestableERC20Wrapper, bound to a specific deployed contract. 2936 func NewRequestableERC20WrapperTransactor(address common.Address, transactor bind.ContractTransactor) (*RequestableERC20WrapperTransactor, error) { 2937 contract, err := bindRequestableERC20Wrapper(address, nil, transactor, nil) 2938 if err != nil { 2939 return nil, err 2940 } 2941 return &RequestableERC20WrapperTransactor{contract: contract}, nil 2942 } 2943 2944 // NewRequestableERC20WrapperFilterer creates a new log filterer instance of RequestableERC20Wrapper, bound to a specific deployed contract. 2945 func NewRequestableERC20WrapperFilterer(address common.Address, filterer bind.ContractFilterer) (*RequestableERC20WrapperFilterer, error) { 2946 contract, err := bindRequestableERC20Wrapper(address, nil, nil, filterer) 2947 if err != nil { 2948 return nil, err 2949 } 2950 return &RequestableERC20WrapperFilterer{contract: contract}, nil 2951 } 2952 2953 // bindRequestableERC20Wrapper binds a generic wrapper to an already deployed contract. 2954 func bindRequestableERC20Wrapper(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 2955 parsed, err := abi.JSON(strings.NewReader(RequestableERC20WrapperABI)) 2956 if err != nil { 2957 return nil, err 2958 } 2959 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 2960 } 2961 2962 // Call invokes the (constant) contract method with params as input values and 2963 // sets the output to result. The result type might be a single field for simple 2964 // returns, a slice of interfaces for anonymous returns and a struct for named 2965 // returns. 2966 func (_RequestableERC20Wrapper *RequestableERC20WrapperRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 2967 return _RequestableERC20Wrapper.Contract.RequestableERC20WrapperCaller.contract.Call(opts, result, method, params...) 2968 } 2969 2970 // Transfer initiates a plain transaction to move funds to the contract, calling 2971 // its default method if one is available. 2972 func (_RequestableERC20Wrapper *RequestableERC20WrapperRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 2973 return _RequestableERC20Wrapper.Contract.RequestableERC20WrapperTransactor.contract.Transfer(opts) 2974 } 2975 2976 // Transact invokes the (paid) contract method with params as input values. 2977 func (_RequestableERC20Wrapper *RequestableERC20WrapperRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 2978 return _RequestableERC20Wrapper.Contract.RequestableERC20WrapperTransactor.contract.Transact(opts, method, params...) 2979 } 2980 2981 // Call invokes the (constant) contract method with params as input values and 2982 // sets the output to result. The result type might be a single field for simple 2983 // returns, a slice of interfaces for anonymous returns and a struct for named 2984 // returns. 2985 func (_RequestableERC20Wrapper *RequestableERC20WrapperCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 2986 return _RequestableERC20Wrapper.Contract.contract.Call(opts, result, method, params...) 2987 } 2988 2989 // Transfer initiates a plain transaction to move funds to the contract, calling 2990 // its default method if one is available. 2991 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 2992 return _RequestableERC20Wrapper.Contract.contract.Transfer(opts) 2993 } 2994 2995 // Transact invokes the (paid) contract method with params as input values. 2996 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 2997 return _RequestableERC20Wrapper.Contract.contract.Transact(opts, method, params...) 2998 } 2999 3000 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 3001 // 3002 // Solidity: function allowance(address _owner, address _spender) constant returns(uint256) 3003 func (_RequestableERC20Wrapper *RequestableERC20WrapperCaller) Allowance(opts *bind.CallOpts, _owner common.Address, _spender common.Address) (*big.Int, error) { 3004 var ( 3005 ret0 = new(*big.Int) 3006 ) 3007 out := ret0 3008 err := _RequestableERC20Wrapper.contract.Call(opts, out, "allowance", _owner, _spender) 3009 return *ret0, err 3010 } 3011 3012 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 3013 // 3014 // Solidity: function allowance(address _owner, address _spender) constant returns(uint256) 3015 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) { 3016 return _RequestableERC20Wrapper.Contract.Allowance(&_RequestableERC20Wrapper.CallOpts, _owner, _spender) 3017 } 3018 3019 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 3020 // 3021 // Solidity: function allowance(address _owner, address _spender) constant returns(uint256) 3022 func (_RequestableERC20Wrapper *RequestableERC20WrapperCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) { 3023 return _RequestableERC20Wrapper.Contract.Allowance(&_RequestableERC20Wrapper.CallOpts, _owner, _spender) 3024 } 3025 3026 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 3027 // 3028 // Solidity: function balanceOf(address _owner) constant returns(uint256) 3029 func (_RequestableERC20Wrapper *RequestableERC20WrapperCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) { 3030 var ( 3031 ret0 = new(*big.Int) 3032 ) 3033 out := ret0 3034 err := _RequestableERC20Wrapper.contract.Call(opts, out, "balanceOf", _owner) 3035 return *ret0, err 3036 } 3037 3038 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 3039 // 3040 // Solidity: function balanceOf(address _owner) constant returns(uint256) 3041 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) BalanceOf(_owner common.Address) (*big.Int, error) { 3042 return _RequestableERC20Wrapper.Contract.BalanceOf(&_RequestableERC20Wrapper.CallOpts, _owner) 3043 } 3044 3045 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 3046 // 3047 // Solidity: function balanceOf(address _owner) constant returns(uint256) 3048 func (_RequestableERC20Wrapper *RequestableERC20WrapperCallerSession) BalanceOf(_owner common.Address) (*big.Int, error) { 3049 return _RequestableERC20Wrapper.Contract.BalanceOf(&_RequestableERC20Wrapper.CallOpts, _owner) 3050 } 3051 3052 // DecodeTrieValue is a free data retrieval call binding the contract method 0xb9e59d09. 3053 // 3054 // Solidity: function decodeTrieValue(bytes trieValue) constant returns(uint256 v) 3055 func (_RequestableERC20Wrapper *RequestableERC20WrapperCaller) DecodeTrieValue(opts *bind.CallOpts, trieValue []byte) (*big.Int, error) { 3056 var ( 3057 ret0 = new(*big.Int) 3058 ) 3059 out := ret0 3060 err := _RequestableERC20Wrapper.contract.Call(opts, out, "decodeTrieValue", trieValue) 3061 return *ret0, err 3062 } 3063 3064 // DecodeTrieValue is a free data retrieval call binding the contract method 0xb9e59d09. 3065 // 3066 // Solidity: function decodeTrieValue(bytes trieValue) constant returns(uint256 v) 3067 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) DecodeTrieValue(trieValue []byte) (*big.Int, error) { 3068 return _RequestableERC20Wrapper.Contract.DecodeTrieValue(&_RequestableERC20Wrapper.CallOpts, trieValue) 3069 } 3070 3071 // DecodeTrieValue is a free data retrieval call binding the contract method 0xb9e59d09. 3072 // 3073 // Solidity: function decodeTrieValue(bytes trieValue) constant returns(uint256 v) 3074 func (_RequestableERC20Wrapper *RequestableERC20WrapperCallerSession) DecodeTrieValue(trieValue []byte) (*big.Int, error) { 3075 return _RequestableERC20Wrapper.Contract.DecodeTrieValue(&_RequestableERC20Wrapper.CallOpts, trieValue) 3076 } 3077 3078 // Development is a free data retrieval call binding the contract method 0x7b929c27. 3079 // 3080 // Solidity: function development() constant returns(bool) 3081 func (_RequestableERC20Wrapper *RequestableERC20WrapperCaller) Development(opts *bind.CallOpts) (bool, error) { 3082 var ( 3083 ret0 = new(bool) 3084 ) 3085 out := ret0 3086 err := _RequestableERC20Wrapper.contract.Call(opts, out, "development") 3087 return *ret0, err 3088 } 3089 3090 // Development is a free data retrieval call binding the contract method 0x7b929c27. 3091 // 3092 // Solidity: function development() constant returns(bool) 3093 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) Development() (bool, error) { 3094 return _RequestableERC20Wrapper.Contract.Development(&_RequestableERC20Wrapper.CallOpts) 3095 } 3096 3097 // Development is a free data retrieval call binding the contract method 0x7b929c27. 3098 // 3099 // Solidity: function development() constant returns(bool) 3100 func (_RequestableERC20Wrapper *RequestableERC20WrapperCallerSession) Development() (bool, error) { 3101 return _RequestableERC20Wrapper.Contract.Development(&_RequestableERC20Wrapper.CallOpts) 3102 } 3103 3104 // GetBalanceTrieKey is a free data retrieval call binding the contract method 0xb18fcfdf. 3105 // 3106 // Solidity: function getBalanceTrieKey(address _who) constant returns(bytes32) 3107 func (_RequestableERC20Wrapper *RequestableERC20WrapperCaller) GetBalanceTrieKey(opts *bind.CallOpts, _who common.Address) ([32]byte, error) { 3108 var ( 3109 ret0 = new([32]byte) 3110 ) 3111 out := ret0 3112 err := _RequestableERC20Wrapper.contract.Call(opts, out, "getBalanceTrieKey", _who) 3113 return *ret0, err 3114 } 3115 3116 // GetBalanceTrieKey is a free data retrieval call binding the contract method 0xb18fcfdf. 3117 // 3118 // Solidity: function getBalanceTrieKey(address _who) constant returns(bytes32) 3119 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) GetBalanceTrieKey(_who common.Address) ([32]byte, error) { 3120 return _RequestableERC20Wrapper.Contract.GetBalanceTrieKey(&_RequestableERC20Wrapper.CallOpts, _who) 3121 } 3122 3123 // GetBalanceTrieKey is a free data retrieval call binding the contract method 0xb18fcfdf. 3124 // 3125 // Solidity: function getBalanceTrieKey(address _who) constant returns(bytes32) 3126 func (_RequestableERC20Wrapper *RequestableERC20WrapperCallerSession) GetBalanceTrieKey(_who common.Address) ([32]byte, error) { 3127 return _RequestableERC20Wrapper.Contract.GetBalanceTrieKey(&_RequestableERC20Wrapper.CallOpts, _who) 3128 } 3129 3130 // Initialized is a free data retrieval call binding the contract method 0x158ef93e. 3131 // 3132 // Solidity: function initialized() constant returns(bool) 3133 func (_RequestableERC20Wrapper *RequestableERC20WrapperCaller) Initialized(opts *bind.CallOpts) (bool, error) { 3134 var ( 3135 ret0 = new(bool) 3136 ) 3137 out := ret0 3138 err := _RequestableERC20Wrapper.contract.Call(opts, out, "initialized") 3139 return *ret0, err 3140 } 3141 3142 // Initialized is a free data retrieval call binding the contract method 0x158ef93e. 3143 // 3144 // Solidity: function initialized() constant returns(bool) 3145 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) Initialized() (bool, error) { 3146 return _RequestableERC20Wrapper.Contract.Initialized(&_RequestableERC20Wrapper.CallOpts) 3147 } 3148 3149 // Initialized is a free data retrieval call binding the contract method 0x158ef93e. 3150 // 3151 // Solidity: function initialized() constant returns(bool) 3152 func (_RequestableERC20Wrapper *RequestableERC20WrapperCallerSession) Initialized() (bool, error) { 3153 return _RequestableERC20Wrapper.Contract.Initialized(&_RequestableERC20Wrapper.CallOpts) 3154 } 3155 3156 // Rootchain is a free data retrieval call binding the contract method 0xbcc7874d. 3157 // 3158 // Solidity: function rootchain() constant returns(address) 3159 func (_RequestableERC20Wrapper *RequestableERC20WrapperCaller) Rootchain(opts *bind.CallOpts) (common.Address, error) { 3160 var ( 3161 ret0 = new(common.Address) 3162 ) 3163 out := ret0 3164 err := _RequestableERC20Wrapper.contract.Call(opts, out, "rootchain") 3165 return *ret0, err 3166 } 3167 3168 // Rootchain is a free data retrieval call binding the contract method 0xbcc7874d. 3169 // 3170 // Solidity: function rootchain() constant returns(address) 3171 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) Rootchain() (common.Address, error) { 3172 return _RequestableERC20Wrapper.Contract.Rootchain(&_RequestableERC20Wrapper.CallOpts) 3173 } 3174 3175 // Rootchain is a free data retrieval call binding the contract method 0xbcc7874d. 3176 // 3177 // Solidity: function rootchain() constant returns(address) 3178 func (_RequestableERC20Wrapper *RequestableERC20WrapperCallerSession) Rootchain() (common.Address, error) { 3179 return _RequestableERC20Wrapper.Contract.Rootchain(&_RequestableERC20Wrapper.CallOpts) 3180 } 3181 3182 // Token is a free data retrieval call binding the contract method 0xfc0c546a. 3183 // 3184 // Solidity: function token() constant returns(address) 3185 func (_RequestableERC20Wrapper *RequestableERC20WrapperCaller) Token(opts *bind.CallOpts) (common.Address, error) { 3186 var ( 3187 ret0 = new(common.Address) 3188 ) 3189 out := ret0 3190 err := _RequestableERC20Wrapper.contract.Call(opts, out, "token") 3191 return *ret0, err 3192 } 3193 3194 // Token is a free data retrieval call binding the contract method 0xfc0c546a. 3195 // 3196 // Solidity: function token() constant returns(address) 3197 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) Token() (common.Address, error) { 3198 return _RequestableERC20Wrapper.Contract.Token(&_RequestableERC20Wrapper.CallOpts) 3199 } 3200 3201 // Token is a free data retrieval call binding the contract method 0xfc0c546a. 3202 // 3203 // Solidity: function token() constant returns(address) 3204 func (_RequestableERC20Wrapper *RequestableERC20WrapperCallerSession) Token() (common.Address, error) { 3205 return _RequestableERC20Wrapper.Contract.Token(&_RequestableERC20Wrapper.CallOpts) 3206 } 3207 3208 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 3209 // 3210 // Solidity: function totalSupply() constant returns(uint256) 3211 func (_RequestableERC20Wrapper *RequestableERC20WrapperCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 3212 var ( 3213 ret0 = new(*big.Int) 3214 ) 3215 out := ret0 3216 err := _RequestableERC20Wrapper.contract.Call(opts, out, "totalSupply") 3217 return *ret0, err 3218 } 3219 3220 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 3221 // 3222 // Solidity: function totalSupply() constant returns(uint256) 3223 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) TotalSupply() (*big.Int, error) { 3224 return _RequestableERC20Wrapper.Contract.TotalSupply(&_RequestableERC20Wrapper.CallOpts) 3225 } 3226 3227 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 3228 // 3229 // Solidity: function totalSupply() constant returns(uint256) 3230 func (_RequestableERC20Wrapper *RequestableERC20WrapperCallerSession) TotalSupply() (*big.Int, error) { 3231 return _RequestableERC20Wrapper.Contract.TotalSupply(&_RequestableERC20Wrapper.CallOpts) 3232 } 3233 3234 // ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46. 3235 // 3236 // Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 3237 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactor) ApplyRequestInChildChain(opts *bind.TransactOpts, isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 3238 return _RequestableERC20Wrapper.contract.Transact(opts, "applyRequestInChildChain", isExit, requestId, requestor, trieKey, trieValue) 3239 } 3240 3241 // ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46. 3242 // 3243 // Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 3244 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) ApplyRequestInChildChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 3245 return _RequestableERC20Wrapper.Contract.ApplyRequestInChildChain(&_RequestableERC20Wrapper.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 3246 } 3247 3248 // ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46. 3249 // 3250 // Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 3251 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactorSession) ApplyRequestInChildChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 3252 return _RequestableERC20Wrapper.Contract.ApplyRequestInChildChain(&_RequestableERC20Wrapper.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 3253 } 3254 3255 // ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308. 3256 // 3257 // Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 3258 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactor) ApplyRequestInRootChain(opts *bind.TransactOpts, isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 3259 return _RequestableERC20Wrapper.contract.Transact(opts, "applyRequestInRootChain", isExit, requestId, requestor, trieKey, trieValue) 3260 } 3261 3262 // ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308. 3263 // 3264 // Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 3265 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) ApplyRequestInRootChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 3266 return _RequestableERC20Wrapper.Contract.ApplyRequestInRootChain(&_RequestableERC20Wrapper.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 3267 } 3268 3269 // ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308. 3270 // 3271 // Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 3272 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactorSession) ApplyRequestInRootChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 3273 return _RequestableERC20Wrapper.Contract.ApplyRequestInRootChain(&_RequestableERC20Wrapper.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 3274 } 3275 3276 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 3277 // 3278 // Solidity: function approve(address _spender, uint256 _value) returns(bool) 3279 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactor) Approve(opts *bind.TransactOpts, _spender common.Address, _value *big.Int) (*types.Transaction, error) { 3280 return _RequestableERC20Wrapper.contract.Transact(opts, "approve", _spender, _value) 3281 } 3282 3283 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 3284 // 3285 // Solidity: function approve(address _spender, uint256 _value) returns(bool) 3286 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) { 3287 return _RequestableERC20Wrapper.Contract.Approve(&_RequestableERC20Wrapper.TransactOpts, _spender, _value) 3288 } 3289 3290 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 3291 // 3292 // Solidity: function approve(address _spender, uint256 _value) returns(bool) 3293 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactorSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) { 3294 return _RequestableERC20Wrapper.Contract.Approve(&_RequestableERC20Wrapper.TransactOpts, _spender, _value) 3295 } 3296 3297 // DecreaseApproval is a paid mutator transaction binding the contract method 0x66188463. 3298 // 3299 // Solidity: function decreaseApproval(address _spender, uint256 _subtractedValue) returns(bool) 3300 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactor) DecreaseApproval(opts *bind.TransactOpts, _spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error) { 3301 return _RequestableERC20Wrapper.contract.Transact(opts, "decreaseApproval", _spender, _subtractedValue) 3302 } 3303 3304 // DecreaseApproval is a paid mutator transaction binding the contract method 0x66188463. 3305 // 3306 // Solidity: function decreaseApproval(address _spender, uint256 _subtractedValue) returns(bool) 3307 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) DecreaseApproval(_spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error) { 3308 return _RequestableERC20Wrapper.Contract.DecreaseApproval(&_RequestableERC20Wrapper.TransactOpts, _spender, _subtractedValue) 3309 } 3310 3311 // DecreaseApproval is a paid mutator transaction binding the contract method 0x66188463. 3312 // 3313 // Solidity: function decreaseApproval(address _spender, uint256 _subtractedValue) returns(bool) 3314 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactorSession) DecreaseApproval(_spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error) { 3315 return _RequestableERC20Wrapper.Contract.DecreaseApproval(&_RequestableERC20Wrapper.TransactOpts, _spender, _subtractedValue) 3316 } 3317 3318 // Deposit is a paid mutator transaction binding the contract method 0xb6b55f25. 3319 // 3320 // Solidity: function deposit(uint256 _amount) returns(bool) 3321 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactor) Deposit(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error) { 3322 return _RequestableERC20Wrapper.contract.Transact(opts, "deposit", _amount) 3323 } 3324 3325 // Deposit is a paid mutator transaction binding the contract method 0xb6b55f25. 3326 // 3327 // Solidity: function deposit(uint256 _amount) returns(bool) 3328 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) Deposit(_amount *big.Int) (*types.Transaction, error) { 3329 return _RequestableERC20Wrapper.Contract.Deposit(&_RequestableERC20Wrapper.TransactOpts, _amount) 3330 } 3331 3332 // Deposit is a paid mutator transaction binding the contract method 0xb6b55f25. 3333 // 3334 // Solidity: function deposit(uint256 _amount) returns(bool) 3335 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactorSession) Deposit(_amount *big.Int) (*types.Transaction, error) { 3336 return _RequestableERC20Wrapper.Contract.Deposit(&_RequestableERC20Wrapper.TransactOpts, _amount) 3337 } 3338 3339 // IncreaseApproval is a paid mutator transaction binding the contract method 0xd73dd623. 3340 // 3341 // Solidity: function increaseApproval(address _spender, uint256 _addedValue) returns(bool) 3342 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactor) IncreaseApproval(opts *bind.TransactOpts, _spender common.Address, _addedValue *big.Int) (*types.Transaction, error) { 3343 return _RequestableERC20Wrapper.contract.Transact(opts, "increaseApproval", _spender, _addedValue) 3344 } 3345 3346 // IncreaseApproval is a paid mutator transaction binding the contract method 0xd73dd623. 3347 // 3348 // Solidity: function increaseApproval(address _spender, uint256 _addedValue) returns(bool) 3349 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) IncreaseApproval(_spender common.Address, _addedValue *big.Int) (*types.Transaction, error) { 3350 return _RequestableERC20Wrapper.Contract.IncreaseApproval(&_RequestableERC20Wrapper.TransactOpts, _spender, _addedValue) 3351 } 3352 3353 // IncreaseApproval is a paid mutator transaction binding the contract method 0xd73dd623. 3354 // 3355 // Solidity: function increaseApproval(address _spender, uint256 _addedValue) returns(bool) 3356 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactorSession) IncreaseApproval(_spender common.Address, _addedValue *big.Int) (*types.Transaction, error) { 3357 return _RequestableERC20Wrapper.Contract.IncreaseApproval(&_RequestableERC20Wrapper.TransactOpts, _spender, _addedValue) 3358 } 3359 3360 // Init is a paid mutator transaction binding the contract method 0x19ab453c. 3361 // 3362 // Solidity: function init(address _rootchain) returns(bool) 3363 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactor) Init(opts *bind.TransactOpts, _rootchain common.Address) (*types.Transaction, error) { 3364 return _RequestableERC20Wrapper.contract.Transact(opts, "init", _rootchain) 3365 } 3366 3367 // Init is a paid mutator transaction binding the contract method 0x19ab453c. 3368 // 3369 // Solidity: function init(address _rootchain) returns(bool) 3370 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) Init(_rootchain common.Address) (*types.Transaction, error) { 3371 return _RequestableERC20Wrapper.Contract.Init(&_RequestableERC20Wrapper.TransactOpts, _rootchain) 3372 } 3373 3374 // Init is a paid mutator transaction binding the contract method 0x19ab453c. 3375 // 3376 // Solidity: function init(address _rootchain) returns(bool) 3377 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactorSession) Init(_rootchain common.Address) (*types.Transaction, error) { 3378 return _RequestableERC20Wrapper.Contract.Init(&_RequestableERC20Wrapper.TransactOpts, _rootchain) 3379 } 3380 3381 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 3382 // 3383 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 3384 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error) { 3385 return _RequestableERC20Wrapper.contract.Transact(opts, "transfer", _to, _value) 3386 } 3387 3388 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 3389 // 3390 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 3391 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { 3392 return _RequestableERC20Wrapper.Contract.Transfer(&_RequestableERC20Wrapper.TransactOpts, _to, _value) 3393 } 3394 3395 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 3396 // 3397 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 3398 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { 3399 return _RequestableERC20Wrapper.Contract.Transfer(&_RequestableERC20Wrapper.TransactOpts, _to, _value) 3400 } 3401 3402 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 3403 // 3404 // Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool) 3405 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { 3406 return _RequestableERC20Wrapper.contract.Transact(opts, "transferFrom", _from, _to, _value) 3407 } 3408 3409 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 3410 // 3411 // Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool) 3412 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { 3413 return _RequestableERC20Wrapper.Contract.TransferFrom(&_RequestableERC20Wrapper.TransactOpts, _from, _to, _value) 3414 } 3415 3416 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 3417 // 3418 // Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool) 3419 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactorSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { 3420 return _RequestableERC20Wrapper.Contract.TransferFrom(&_RequestableERC20Wrapper.TransactOpts, _from, _to, _value) 3421 } 3422 3423 // Withdraw is a paid mutator transaction binding the contract method 0x2e1a7d4d. 3424 // 3425 // Solidity: function withdraw(uint256 _amount) returns(bool) 3426 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactor) Withdraw(opts *bind.TransactOpts, _amount *big.Int) (*types.Transaction, error) { 3427 return _RequestableERC20Wrapper.contract.Transact(opts, "withdraw", _amount) 3428 } 3429 3430 // Withdraw is a paid mutator transaction binding the contract method 0x2e1a7d4d. 3431 // 3432 // Solidity: function withdraw(uint256 _amount) returns(bool) 3433 func (_RequestableERC20Wrapper *RequestableERC20WrapperSession) Withdraw(_amount *big.Int) (*types.Transaction, error) { 3434 return _RequestableERC20Wrapper.Contract.Withdraw(&_RequestableERC20Wrapper.TransactOpts, _amount) 3435 } 3436 3437 // Withdraw is a paid mutator transaction binding the contract method 0x2e1a7d4d. 3438 // 3439 // Solidity: function withdraw(uint256 _amount) returns(bool) 3440 func (_RequestableERC20Wrapper *RequestableERC20WrapperTransactorSession) Withdraw(_amount *big.Int) (*types.Transaction, error) { 3441 return _RequestableERC20Wrapper.Contract.Withdraw(&_RequestableERC20Wrapper.TransactOpts, _amount) 3442 } 3443 3444 // RequestableERC20WrapperApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the RequestableERC20Wrapper contract. 3445 type RequestableERC20WrapperApprovalIterator struct { 3446 Event *RequestableERC20WrapperApproval // Event containing the contract specifics and raw log 3447 3448 contract *bind.BoundContract // Generic contract to use for unpacking event data 3449 event string // Event name to use for unpacking event data 3450 3451 logs chan types.Log // Log channel receiving the found contract events 3452 sub ethereum.Subscription // Subscription for errors, completion and termination 3453 done bool // Whether the subscription completed delivering logs 3454 fail error // Occurred error to stop iteration 3455 } 3456 3457 // Next advances the iterator to the subsequent event, returning whether there 3458 // are any more events found. In case of a retrieval or parsing error, false is 3459 // returned and Error() can be queried for the exact failure. 3460 func (it *RequestableERC20WrapperApprovalIterator) Next() bool { 3461 // If the iterator failed, stop iterating 3462 if it.fail != nil { 3463 return false 3464 } 3465 // If the iterator completed, deliver directly whatever's available 3466 if it.done { 3467 select { 3468 case log := <-it.logs: 3469 it.Event = new(RequestableERC20WrapperApproval) 3470 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 3471 it.fail = err 3472 return false 3473 } 3474 it.Event.Raw = log 3475 return true 3476 3477 default: 3478 return false 3479 } 3480 } 3481 // Iterator still in progress, wait for either a data or an error event 3482 select { 3483 case log := <-it.logs: 3484 it.Event = new(RequestableERC20WrapperApproval) 3485 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 3486 it.fail = err 3487 return false 3488 } 3489 it.Event.Raw = log 3490 return true 3491 3492 case err := <-it.sub.Err(): 3493 it.done = true 3494 it.fail = err 3495 return it.Next() 3496 } 3497 } 3498 3499 // Error returns any retrieval or parsing error occurred during filtering. 3500 func (it *RequestableERC20WrapperApprovalIterator) Error() error { 3501 return it.fail 3502 } 3503 3504 // Close terminates the iteration process, releasing any pending underlying 3505 // resources. 3506 func (it *RequestableERC20WrapperApprovalIterator) Close() error { 3507 it.sub.Unsubscribe() 3508 return nil 3509 } 3510 3511 // RequestableERC20WrapperApproval represents a Approval event raised by the RequestableERC20Wrapper contract. 3512 type RequestableERC20WrapperApproval struct { 3513 Owner common.Address 3514 Spender common.Address 3515 Value *big.Int 3516 Raw types.Log // Blockchain specific contextual infos 3517 } 3518 3519 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 3520 // 3521 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 3522 func (_RequestableERC20Wrapper *RequestableERC20WrapperFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*RequestableERC20WrapperApprovalIterator, error) { 3523 3524 var ownerRule []interface{} 3525 for _, ownerItem := range owner { 3526 ownerRule = append(ownerRule, ownerItem) 3527 } 3528 var spenderRule []interface{} 3529 for _, spenderItem := range spender { 3530 spenderRule = append(spenderRule, spenderItem) 3531 } 3532 3533 logs, sub, err := _RequestableERC20Wrapper.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 3534 if err != nil { 3535 return nil, err 3536 } 3537 return &RequestableERC20WrapperApprovalIterator{contract: _RequestableERC20Wrapper.contract, event: "Approval", logs: logs, sub: sub}, nil 3538 } 3539 3540 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 3541 // 3542 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 3543 func (_RequestableERC20Wrapper *RequestableERC20WrapperFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *RequestableERC20WrapperApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 3544 3545 var ownerRule []interface{} 3546 for _, ownerItem := range owner { 3547 ownerRule = append(ownerRule, ownerItem) 3548 } 3549 var spenderRule []interface{} 3550 for _, spenderItem := range spender { 3551 spenderRule = append(spenderRule, spenderItem) 3552 } 3553 3554 logs, sub, err := _RequestableERC20Wrapper.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 3555 if err != nil { 3556 return nil, err 3557 } 3558 return event.NewSubscription(func(quit <-chan struct{}) error { 3559 defer sub.Unsubscribe() 3560 for { 3561 select { 3562 case log := <-logs: 3563 // New log arrived, parse the event and forward to the user 3564 event := new(RequestableERC20WrapperApproval) 3565 if err := _RequestableERC20Wrapper.contract.UnpackLog(event, "Approval", log); err != nil { 3566 return err 3567 } 3568 event.Raw = log 3569 3570 select { 3571 case sink <- event: 3572 case err := <-sub.Err(): 3573 return err 3574 case <-quit: 3575 return nil 3576 } 3577 case err := <-sub.Err(): 3578 return err 3579 case <-quit: 3580 return nil 3581 } 3582 } 3583 }), nil 3584 } 3585 3586 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 3587 // 3588 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 3589 func (_RequestableERC20Wrapper *RequestableERC20WrapperFilterer) ParseApproval(log types.Log) (*RequestableERC20WrapperApproval, error) { 3590 event := new(RequestableERC20WrapperApproval) 3591 if err := _RequestableERC20Wrapper.contract.UnpackLog(event, "Approval", log); err != nil { 3592 return nil, err 3593 } 3594 return event, nil 3595 } 3596 3597 // RequestableERC20WrapperDeposittedIterator is returned from FilterDepositted and is used to iterate over the raw logs and unpacked data for Depositted events raised by the RequestableERC20Wrapper contract. 3598 type RequestableERC20WrapperDeposittedIterator struct { 3599 Event *RequestableERC20WrapperDepositted // Event containing the contract specifics and raw log 3600 3601 contract *bind.BoundContract // Generic contract to use for unpacking event data 3602 event string // Event name to use for unpacking event data 3603 3604 logs chan types.Log // Log channel receiving the found contract events 3605 sub ethereum.Subscription // Subscription for errors, completion and termination 3606 done bool // Whether the subscription completed delivering logs 3607 fail error // Occurred error to stop iteration 3608 } 3609 3610 // Next advances the iterator to the subsequent event, returning whether there 3611 // are any more events found. In case of a retrieval or parsing error, false is 3612 // returned and Error() can be queried for the exact failure. 3613 func (it *RequestableERC20WrapperDeposittedIterator) Next() bool { 3614 // If the iterator failed, stop iterating 3615 if it.fail != nil { 3616 return false 3617 } 3618 // If the iterator completed, deliver directly whatever's available 3619 if it.done { 3620 select { 3621 case log := <-it.logs: 3622 it.Event = new(RequestableERC20WrapperDepositted) 3623 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 3624 it.fail = err 3625 return false 3626 } 3627 it.Event.Raw = log 3628 return true 3629 3630 default: 3631 return false 3632 } 3633 } 3634 // Iterator still in progress, wait for either a data or an error event 3635 select { 3636 case log := <-it.logs: 3637 it.Event = new(RequestableERC20WrapperDepositted) 3638 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 3639 it.fail = err 3640 return false 3641 } 3642 it.Event.Raw = log 3643 return true 3644 3645 case err := <-it.sub.Err(): 3646 it.done = true 3647 it.fail = err 3648 return it.Next() 3649 } 3650 } 3651 3652 // Error returns any retrieval or parsing error occurred during filtering. 3653 func (it *RequestableERC20WrapperDeposittedIterator) Error() error { 3654 return it.fail 3655 } 3656 3657 // Close terminates the iteration process, releasing any pending underlying 3658 // resources. 3659 func (it *RequestableERC20WrapperDeposittedIterator) Close() error { 3660 it.sub.Unsubscribe() 3661 return nil 3662 } 3663 3664 // RequestableERC20WrapperDepositted represents a Depositted event raised by the RequestableERC20Wrapper contract. 3665 type RequestableERC20WrapperDepositted struct { 3666 From common.Address 3667 Value *big.Int 3668 Raw types.Log // Blockchain specific contextual infos 3669 } 3670 3671 // FilterDepositted is a free log retrieval operation binding the contract event 0x46fc0825df492a7a7f1fb1b690f6912ecb69575484fbb24be0f398ae70d97db4. 3672 // 3673 // Solidity: event Depositted(address _from, uint256 _value) 3674 func (_RequestableERC20Wrapper *RequestableERC20WrapperFilterer) FilterDepositted(opts *bind.FilterOpts) (*RequestableERC20WrapperDeposittedIterator, error) { 3675 3676 logs, sub, err := _RequestableERC20Wrapper.contract.FilterLogs(opts, "Depositted") 3677 if err != nil { 3678 return nil, err 3679 } 3680 return &RequestableERC20WrapperDeposittedIterator{contract: _RequestableERC20Wrapper.contract, event: "Depositted", logs: logs, sub: sub}, nil 3681 } 3682 3683 // WatchDepositted is a free log subscription operation binding the contract event 0x46fc0825df492a7a7f1fb1b690f6912ecb69575484fbb24be0f398ae70d97db4. 3684 // 3685 // Solidity: event Depositted(address _from, uint256 _value) 3686 func (_RequestableERC20Wrapper *RequestableERC20WrapperFilterer) WatchDepositted(opts *bind.WatchOpts, sink chan<- *RequestableERC20WrapperDepositted) (event.Subscription, error) { 3687 3688 logs, sub, err := _RequestableERC20Wrapper.contract.WatchLogs(opts, "Depositted") 3689 if err != nil { 3690 return nil, err 3691 } 3692 return event.NewSubscription(func(quit <-chan struct{}) error { 3693 defer sub.Unsubscribe() 3694 for { 3695 select { 3696 case log := <-logs: 3697 // New log arrived, parse the event and forward to the user 3698 event := new(RequestableERC20WrapperDepositted) 3699 if err := _RequestableERC20Wrapper.contract.UnpackLog(event, "Depositted", log); err != nil { 3700 return err 3701 } 3702 event.Raw = log 3703 3704 select { 3705 case sink <- event: 3706 case err := <-sub.Err(): 3707 return err 3708 case <-quit: 3709 return nil 3710 } 3711 case err := <-sub.Err(): 3712 return err 3713 case <-quit: 3714 return nil 3715 } 3716 } 3717 }), nil 3718 } 3719 3720 // ParseDepositted is a log parse operation binding the contract event 0x46fc0825df492a7a7f1fb1b690f6912ecb69575484fbb24be0f398ae70d97db4. 3721 // 3722 // Solidity: event Depositted(address _from, uint256 _value) 3723 func (_RequestableERC20Wrapper *RequestableERC20WrapperFilterer) ParseDepositted(log types.Log) (*RequestableERC20WrapperDepositted, error) { 3724 event := new(RequestableERC20WrapperDepositted) 3725 if err := _RequestableERC20Wrapper.contract.UnpackLog(event, "Depositted", log); err != nil { 3726 return nil, err 3727 } 3728 return event, nil 3729 } 3730 3731 // RequestableERC20WrapperRequestCreatedIterator is returned from FilterRequestCreated and is used to iterate over the raw logs and unpacked data for RequestCreated events raised by the RequestableERC20Wrapper contract. 3732 type RequestableERC20WrapperRequestCreatedIterator struct { 3733 Event *RequestableERC20WrapperRequestCreated // Event containing the contract specifics and raw log 3734 3735 contract *bind.BoundContract // Generic contract to use for unpacking event data 3736 event string // Event name to use for unpacking event data 3737 3738 logs chan types.Log // Log channel receiving the found contract events 3739 sub ethereum.Subscription // Subscription for errors, completion and termination 3740 done bool // Whether the subscription completed delivering logs 3741 fail error // Occurred error to stop iteration 3742 } 3743 3744 // Next advances the iterator to the subsequent event, returning whether there 3745 // are any more events found. In case of a retrieval or parsing error, false is 3746 // returned and Error() can be queried for the exact failure. 3747 func (it *RequestableERC20WrapperRequestCreatedIterator) Next() bool { 3748 // If the iterator failed, stop iterating 3749 if it.fail != nil { 3750 return false 3751 } 3752 // If the iterator completed, deliver directly whatever's available 3753 if it.done { 3754 select { 3755 case log := <-it.logs: 3756 it.Event = new(RequestableERC20WrapperRequestCreated) 3757 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 3758 it.fail = err 3759 return false 3760 } 3761 it.Event.Raw = log 3762 return true 3763 3764 default: 3765 return false 3766 } 3767 } 3768 // Iterator still in progress, wait for either a data or an error event 3769 select { 3770 case log := <-it.logs: 3771 it.Event = new(RequestableERC20WrapperRequestCreated) 3772 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 3773 it.fail = err 3774 return false 3775 } 3776 it.Event.Raw = log 3777 return true 3778 3779 case err := <-it.sub.Err(): 3780 it.done = true 3781 it.fail = err 3782 return it.Next() 3783 } 3784 } 3785 3786 // Error returns any retrieval or parsing error occurred during filtering. 3787 func (it *RequestableERC20WrapperRequestCreatedIterator) Error() error { 3788 return it.fail 3789 } 3790 3791 // Close terminates the iteration process, releasing any pending underlying 3792 // resources. 3793 func (it *RequestableERC20WrapperRequestCreatedIterator) Close() error { 3794 it.sub.Unsubscribe() 3795 return nil 3796 } 3797 3798 // RequestableERC20WrapperRequestCreated represents a RequestCreated event raised by the RequestableERC20Wrapper contract. 3799 type RequestableERC20WrapperRequestCreated struct { 3800 IsExit bool 3801 Requestor common.Address 3802 TrieKey [32]byte 3803 Value *big.Int 3804 Raw types.Log // Blockchain specific contextual infos 3805 } 3806 3807 // FilterRequestCreated is a free log retrieval operation binding the contract event 0x4b0c23cd90bac23cdaa0958fbd0306f53e20cd5e65676d21b9ceb109784e15b8. 3808 // 3809 // Solidity: event RequestCreated(bool _isExit, address _requestor, bytes32 _trieKey, uint256 _value) 3810 func (_RequestableERC20Wrapper *RequestableERC20WrapperFilterer) FilterRequestCreated(opts *bind.FilterOpts) (*RequestableERC20WrapperRequestCreatedIterator, error) { 3811 3812 logs, sub, err := _RequestableERC20Wrapper.contract.FilterLogs(opts, "RequestCreated") 3813 if err != nil { 3814 return nil, err 3815 } 3816 return &RequestableERC20WrapperRequestCreatedIterator{contract: _RequestableERC20Wrapper.contract, event: "RequestCreated", logs: logs, sub: sub}, nil 3817 } 3818 3819 // WatchRequestCreated is a free log subscription operation binding the contract event 0x4b0c23cd90bac23cdaa0958fbd0306f53e20cd5e65676d21b9ceb109784e15b8. 3820 // 3821 // Solidity: event RequestCreated(bool _isExit, address _requestor, bytes32 _trieKey, uint256 _value) 3822 func (_RequestableERC20Wrapper *RequestableERC20WrapperFilterer) WatchRequestCreated(opts *bind.WatchOpts, sink chan<- *RequestableERC20WrapperRequestCreated) (event.Subscription, error) { 3823 3824 logs, sub, err := _RequestableERC20Wrapper.contract.WatchLogs(opts, "RequestCreated") 3825 if err != nil { 3826 return nil, err 3827 } 3828 return event.NewSubscription(func(quit <-chan struct{}) error { 3829 defer sub.Unsubscribe() 3830 for { 3831 select { 3832 case log := <-logs: 3833 // New log arrived, parse the event and forward to the user 3834 event := new(RequestableERC20WrapperRequestCreated) 3835 if err := _RequestableERC20Wrapper.contract.UnpackLog(event, "RequestCreated", log); err != nil { 3836 return err 3837 } 3838 event.Raw = log 3839 3840 select { 3841 case sink <- event: 3842 case err := <-sub.Err(): 3843 return err 3844 case <-quit: 3845 return nil 3846 } 3847 case err := <-sub.Err(): 3848 return err 3849 case <-quit: 3850 return nil 3851 } 3852 } 3853 }), nil 3854 } 3855 3856 // ParseRequestCreated is a log parse operation binding the contract event 0x4b0c23cd90bac23cdaa0958fbd0306f53e20cd5e65676d21b9ceb109784e15b8. 3857 // 3858 // Solidity: event RequestCreated(bool _isExit, address _requestor, bytes32 _trieKey, uint256 _value) 3859 func (_RequestableERC20Wrapper *RequestableERC20WrapperFilterer) ParseRequestCreated(log types.Log) (*RequestableERC20WrapperRequestCreated, error) { 3860 event := new(RequestableERC20WrapperRequestCreated) 3861 if err := _RequestableERC20Wrapper.contract.UnpackLog(event, "RequestCreated", log); err != nil { 3862 return nil, err 3863 } 3864 return event, nil 3865 } 3866 3867 // RequestableERC20WrapperTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the RequestableERC20Wrapper contract. 3868 type RequestableERC20WrapperTransferIterator struct { 3869 Event *RequestableERC20WrapperTransfer // Event containing the contract specifics and raw log 3870 3871 contract *bind.BoundContract // Generic contract to use for unpacking event data 3872 event string // Event name to use for unpacking event data 3873 3874 logs chan types.Log // Log channel receiving the found contract events 3875 sub ethereum.Subscription // Subscription for errors, completion and termination 3876 done bool // Whether the subscription completed delivering logs 3877 fail error // Occurred error to stop iteration 3878 } 3879 3880 // Next advances the iterator to the subsequent event, returning whether there 3881 // are any more events found. In case of a retrieval or parsing error, false is 3882 // returned and Error() can be queried for the exact failure. 3883 func (it *RequestableERC20WrapperTransferIterator) Next() bool { 3884 // If the iterator failed, stop iterating 3885 if it.fail != nil { 3886 return false 3887 } 3888 // If the iterator completed, deliver directly whatever's available 3889 if it.done { 3890 select { 3891 case log := <-it.logs: 3892 it.Event = new(RequestableERC20WrapperTransfer) 3893 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 3894 it.fail = err 3895 return false 3896 } 3897 it.Event.Raw = log 3898 return true 3899 3900 default: 3901 return false 3902 } 3903 } 3904 // Iterator still in progress, wait for either a data or an error event 3905 select { 3906 case log := <-it.logs: 3907 it.Event = new(RequestableERC20WrapperTransfer) 3908 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 3909 it.fail = err 3910 return false 3911 } 3912 it.Event.Raw = log 3913 return true 3914 3915 case err := <-it.sub.Err(): 3916 it.done = true 3917 it.fail = err 3918 return it.Next() 3919 } 3920 } 3921 3922 // Error returns any retrieval or parsing error occurred during filtering. 3923 func (it *RequestableERC20WrapperTransferIterator) Error() error { 3924 return it.fail 3925 } 3926 3927 // Close terminates the iteration process, releasing any pending underlying 3928 // resources. 3929 func (it *RequestableERC20WrapperTransferIterator) Close() error { 3930 it.sub.Unsubscribe() 3931 return nil 3932 } 3933 3934 // RequestableERC20WrapperTransfer represents a Transfer event raised by the RequestableERC20Wrapper contract. 3935 type RequestableERC20WrapperTransfer struct { 3936 From common.Address 3937 To common.Address 3938 Value *big.Int 3939 Raw types.Log // Blockchain specific contextual infos 3940 } 3941 3942 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 3943 // 3944 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 3945 func (_RequestableERC20Wrapper *RequestableERC20WrapperFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*RequestableERC20WrapperTransferIterator, error) { 3946 3947 var fromRule []interface{} 3948 for _, fromItem := range from { 3949 fromRule = append(fromRule, fromItem) 3950 } 3951 var toRule []interface{} 3952 for _, toItem := range to { 3953 toRule = append(toRule, toItem) 3954 } 3955 3956 logs, sub, err := _RequestableERC20Wrapper.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 3957 if err != nil { 3958 return nil, err 3959 } 3960 return &RequestableERC20WrapperTransferIterator{contract: _RequestableERC20Wrapper.contract, event: "Transfer", logs: logs, sub: sub}, nil 3961 } 3962 3963 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 3964 // 3965 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 3966 func (_RequestableERC20Wrapper *RequestableERC20WrapperFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *RequestableERC20WrapperTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 3967 3968 var fromRule []interface{} 3969 for _, fromItem := range from { 3970 fromRule = append(fromRule, fromItem) 3971 } 3972 var toRule []interface{} 3973 for _, toItem := range to { 3974 toRule = append(toRule, toItem) 3975 } 3976 3977 logs, sub, err := _RequestableERC20Wrapper.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 3978 if err != nil { 3979 return nil, err 3980 } 3981 return event.NewSubscription(func(quit <-chan struct{}) error { 3982 defer sub.Unsubscribe() 3983 for { 3984 select { 3985 case log := <-logs: 3986 // New log arrived, parse the event and forward to the user 3987 event := new(RequestableERC20WrapperTransfer) 3988 if err := _RequestableERC20Wrapper.contract.UnpackLog(event, "Transfer", log); err != nil { 3989 return err 3990 } 3991 event.Raw = log 3992 3993 select { 3994 case sink <- event: 3995 case err := <-sub.Err(): 3996 return err 3997 case <-quit: 3998 return nil 3999 } 4000 case err := <-sub.Err(): 4001 return err 4002 case <-quit: 4003 return nil 4004 } 4005 } 4006 }), nil 4007 } 4008 4009 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 4010 // 4011 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 4012 func (_RequestableERC20Wrapper *RequestableERC20WrapperFilterer) ParseTransfer(log types.Log) (*RequestableERC20WrapperTransfer, error) { 4013 event := new(RequestableERC20WrapperTransfer) 4014 if err := _RequestableERC20Wrapper.contract.UnpackLog(event, "Transfer", log); err != nil { 4015 return nil, err 4016 } 4017 return event, nil 4018 } 4019 4020 // RequestableERC20WrapperWithdrawnIterator is returned from FilterWithdrawn and is used to iterate over the raw logs and unpacked data for Withdrawn events raised by the RequestableERC20Wrapper contract. 4021 type RequestableERC20WrapperWithdrawnIterator struct { 4022 Event *RequestableERC20WrapperWithdrawn // Event containing the contract specifics and raw log 4023 4024 contract *bind.BoundContract // Generic contract to use for unpacking event data 4025 event string // Event name to use for unpacking event data 4026 4027 logs chan types.Log // Log channel receiving the found contract events 4028 sub ethereum.Subscription // Subscription for errors, completion and termination 4029 done bool // Whether the subscription completed delivering logs 4030 fail error // Occurred error to stop iteration 4031 } 4032 4033 // Next advances the iterator to the subsequent event, returning whether there 4034 // are any more events found. In case of a retrieval or parsing error, false is 4035 // returned and Error() can be queried for the exact failure. 4036 func (it *RequestableERC20WrapperWithdrawnIterator) Next() bool { 4037 // If the iterator failed, stop iterating 4038 if it.fail != nil { 4039 return false 4040 } 4041 // If the iterator completed, deliver directly whatever's available 4042 if it.done { 4043 select { 4044 case log := <-it.logs: 4045 it.Event = new(RequestableERC20WrapperWithdrawn) 4046 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4047 it.fail = err 4048 return false 4049 } 4050 it.Event.Raw = log 4051 return true 4052 4053 default: 4054 return false 4055 } 4056 } 4057 // Iterator still in progress, wait for either a data or an error event 4058 select { 4059 case log := <-it.logs: 4060 it.Event = new(RequestableERC20WrapperWithdrawn) 4061 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4062 it.fail = err 4063 return false 4064 } 4065 it.Event.Raw = log 4066 return true 4067 4068 case err := <-it.sub.Err(): 4069 it.done = true 4070 it.fail = err 4071 return it.Next() 4072 } 4073 } 4074 4075 // Error returns any retrieval or parsing error occurred during filtering. 4076 func (it *RequestableERC20WrapperWithdrawnIterator) Error() error { 4077 return it.fail 4078 } 4079 4080 // Close terminates the iteration process, releasing any pending underlying 4081 // resources. 4082 func (it *RequestableERC20WrapperWithdrawnIterator) Close() error { 4083 it.sub.Unsubscribe() 4084 return nil 4085 } 4086 4087 // RequestableERC20WrapperWithdrawn represents a Withdrawn event raised by the RequestableERC20Wrapper contract. 4088 type RequestableERC20WrapperWithdrawn struct { 4089 From common.Address 4090 Value *big.Int 4091 Raw types.Log // Blockchain specific contextual infos 4092 } 4093 4094 // FilterWithdrawn is a free log retrieval operation binding the contract event 0x7084f5476618d8e60b11ef0d7d3f06914655adb8793e28ff7f018d4c76d505d5. 4095 // 4096 // Solidity: event Withdrawn(address _from, uint256 _value) 4097 func (_RequestableERC20Wrapper *RequestableERC20WrapperFilterer) FilterWithdrawn(opts *bind.FilterOpts) (*RequestableERC20WrapperWithdrawnIterator, error) { 4098 4099 logs, sub, err := _RequestableERC20Wrapper.contract.FilterLogs(opts, "Withdrawn") 4100 if err != nil { 4101 return nil, err 4102 } 4103 return &RequestableERC20WrapperWithdrawnIterator{contract: _RequestableERC20Wrapper.contract, event: "Withdrawn", logs: logs, sub: sub}, nil 4104 } 4105 4106 // WatchWithdrawn is a free log subscription operation binding the contract event 0x7084f5476618d8e60b11ef0d7d3f06914655adb8793e28ff7f018d4c76d505d5. 4107 // 4108 // Solidity: event Withdrawn(address _from, uint256 _value) 4109 func (_RequestableERC20Wrapper *RequestableERC20WrapperFilterer) WatchWithdrawn(opts *bind.WatchOpts, sink chan<- *RequestableERC20WrapperWithdrawn) (event.Subscription, error) { 4110 4111 logs, sub, err := _RequestableERC20Wrapper.contract.WatchLogs(opts, "Withdrawn") 4112 if err != nil { 4113 return nil, err 4114 } 4115 return event.NewSubscription(func(quit <-chan struct{}) error { 4116 defer sub.Unsubscribe() 4117 for { 4118 select { 4119 case log := <-logs: 4120 // New log arrived, parse the event and forward to the user 4121 event := new(RequestableERC20WrapperWithdrawn) 4122 if err := _RequestableERC20Wrapper.contract.UnpackLog(event, "Withdrawn", log); err != nil { 4123 return err 4124 } 4125 event.Raw = log 4126 4127 select { 4128 case sink <- event: 4129 case err := <-sub.Err(): 4130 return err 4131 case <-quit: 4132 return nil 4133 } 4134 case err := <-sub.Err(): 4135 return err 4136 case <-quit: 4137 return nil 4138 } 4139 } 4140 }), nil 4141 } 4142 4143 // ParseWithdrawn is a log parse operation binding the contract event 0x7084f5476618d8e60b11ef0d7d3f06914655adb8793e28ff7f018d4c76d505d5. 4144 // 4145 // Solidity: event Withdrawn(address _from, uint256 _value) 4146 func (_RequestableERC20Wrapper *RequestableERC20WrapperFilterer) ParseWithdrawn(log types.Log) (*RequestableERC20WrapperWithdrawn, error) { 4147 event := new(RequestableERC20WrapperWithdrawn) 4148 if err := _RequestableERC20Wrapper.contract.UnpackLog(event, "Withdrawn", log); err != nil { 4149 return nil, err 4150 } 4151 return event, nil 4152 } 4153 4154 // RequestableIABI is the input ABI used to generate the binding from. 4155 const RequestableIABI = "[{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"isExit\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"requestId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"requestor\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"trieKey\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"trieValue\",\"type\":\"bytes\"}],\"name\":\"applyRequestInChildChain\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"isExit\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"requestId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"requestor\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"trieKey\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"trieValue\",\"type\":\"bytes\"}],\"name\":\"applyRequestInRootChain\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 4156 4157 // RequestableIFuncSigs maps the 4-byte function signature to its string representation. 4158 var RequestableIFuncSigs = map[string]string{ 4159 "141ecf46": "applyRequestInChildChain(bool,uint256,address,bytes32,bytes)", 4160 "a9f79308": "applyRequestInRootChain(bool,uint256,address,bytes32,bytes)", 4161 } 4162 4163 // RequestableI is an auto generated Go binding around an Ethereum contract. 4164 type RequestableI struct { 4165 RequestableICaller // Read-only binding to the contract 4166 RequestableITransactor // Write-only binding to the contract 4167 RequestableIFilterer // Log filterer for contract events 4168 } 4169 4170 // RequestableICaller is an auto generated read-only Go binding around an Ethereum contract. 4171 type RequestableICaller struct { 4172 contract *bind.BoundContract // Generic contract wrapper for the low level calls 4173 } 4174 4175 // RequestableITransactor is an auto generated write-only Go binding around an Ethereum contract. 4176 type RequestableITransactor struct { 4177 contract *bind.BoundContract // Generic contract wrapper for the low level calls 4178 } 4179 4180 // RequestableIFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 4181 type RequestableIFilterer struct { 4182 contract *bind.BoundContract // Generic contract wrapper for the low level calls 4183 } 4184 4185 // RequestableISession is an auto generated Go binding around an Ethereum contract, 4186 // with pre-set call and transact options. 4187 type RequestableISession struct { 4188 Contract *RequestableI // Generic contract binding to set the session for 4189 CallOpts bind.CallOpts // Call options to use throughout this session 4190 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 4191 } 4192 4193 // RequestableICallerSession is an auto generated read-only Go binding around an Ethereum contract, 4194 // with pre-set call options. 4195 type RequestableICallerSession struct { 4196 Contract *RequestableICaller // Generic contract caller binding to set the session for 4197 CallOpts bind.CallOpts // Call options to use throughout this session 4198 } 4199 4200 // RequestableITransactorSession is an auto generated write-only Go binding around an Ethereum contract, 4201 // with pre-set transact options. 4202 type RequestableITransactorSession struct { 4203 Contract *RequestableITransactor // Generic contract transactor binding to set the session for 4204 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 4205 } 4206 4207 // RequestableIRaw is an auto generated low-level Go binding around an Ethereum contract. 4208 type RequestableIRaw struct { 4209 Contract *RequestableI // Generic contract binding to access the raw methods on 4210 } 4211 4212 // RequestableICallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 4213 type RequestableICallerRaw struct { 4214 Contract *RequestableICaller // Generic read-only contract binding to access the raw methods on 4215 } 4216 4217 // RequestableITransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 4218 type RequestableITransactorRaw struct { 4219 Contract *RequestableITransactor // Generic write-only contract binding to access the raw methods on 4220 } 4221 4222 // NewRequestableI creates a new instance of RequestableI, bound to a specific deployed contract. 4223 func NewRequestableI(address common.Address, backend bind.ContractBackend) (*RequestableI, error) { 4224 contract, err := bindRequestableI(address, backend, backend, backend) 4225 if err != nil { 4226 return nil, err 4227 } 4228 return &RequestableI{RequestableICaller: RequestableICaller{contract: contract}, RequestableITransactor: RequestableITransactor{contract: contract}, RequestableIFilterer: RequestableIFilterer{contract: contract}}, nil 4229 } 4230 4231 // NewRequestableICaller creates a new read-only instance of RequestableI, bound to a specific deployed contract. 4232 func NewRequestableICaller(address common.Address, caller bind.ContractCaller) (*RequestableICaller, error) { 4233 contract, err := bindRequestableI(address, caller, nil, nil) 4234 if err != nil { 4235 return nil, err 4236 } 4237 return &RequestableICaller{contract: contract}, nil 4238 } 4239 4240 // NewRequestableITransactor creates a new write-only instance of RequestableI, bound to a specific deployed contract. 4241 func NewRequestableITransactor(address common.Address, transactor bind.ContractTransactor) (*RequestableITransactor, error) { 4242 contract, err := bindRequestableI(address, nil, transactor, nil) 4243 if err != nil { 4244 return nil, err 4245 } 4246 return &RequestableITransactor{contract: contract}, nil 4247 } 4248 4249 // NewRequestableIFilterer creates a new log filterer instance of RequestableI, bound to a specific deployed contract. 4250 func NewRequestableIFilterer(address common.Address, filterer bind.ContractFilterer) (*RequestableIFilterer, error) { 4251 contract, err := bindRequestableI(address, nil, nil, filterer) 4252 if err != nil { 4253 return nil, err 4254 } 4255 return &RequestableIFilterer{contract: contract}, nil 4256 } 4257 4258 // bindRequestableI binds a generic wrapper to an already deployed contract. 4259 func bindRequestableI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 4260 parsed, err := abi.JSON(strings.NewReader(RequestableIABI)) 4261 if err != nil { 4262 return nil, err 4263 } 4264 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 4265 } 4266 4267 // Call invokes the (constant) contract method with params as input values and 4268 // sets the output to result. The result type might be a single field for simple 4269 // returns, a slice of interfaces for anonymous returns and a struct for named 4270 // returns. 4271 func (_RequestableI *RequestableIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 4272 return _RequestableI.Contract.RequestableICaller.contract.Call(opts, result, method, params...) 4273 } 4274 4275 // Transfer initiates a plain transaction to move funds to the contract, calling 4276 // its default method if one is available. 4277 func (_RequestableI *RequestableIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 4278 return _RequestableI.Contract.RequestableITransactor.contract.Transfer(opts) 4279 } 4280 4281 // Transact invokes the (paid) contract method with params as input values. 4282 func (_RequestableI *RequestableIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 4283 return _RequestableI.Contract.RequestableITransactor.contract.Transact(opts, method, params...) 4284 } 4285 4286 // Call invokes the (constant) contract method with params as input values and 4287 // sets the output to result. The result type might be a single field for simple 4288 // returns, a slice of interfaces for anonymous returns and a struct for named 4289 // returns. 4290 func (_RequestableI *RequestableICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 4291 return _RequestableI.Contract.contract.Call(opts, result, method, params...) 4292 } 4293 4294 // Transfer initiates a plain transaction to move funds to the contract, calling 4295 // its default method if one is available. 4296 func (_RequestableI *RequestableITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 4297 return _RequestableI.Contract.contract.Transfer(opts) 4298 } 4299 4300 // Transact invokes the (paid) contract method with params as input values. 4301 func (_RequestableI *RequestableITransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 4302 return _RequestableI.Contract.contract.Transact(opts, method, params...) 4303 } 4304 4305 // ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46. 4306 // 4307 // Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 4308 func (_RequestableI *RequestableITransactor) ApplyRequestInChildChain(opts *bind.TransactOpts, isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 4309 return _RequestableI.contract.Transact(opts, "applyRequestInChildChain", isExit, requestId, requestor, trieKey, trieValue) 4310 } 4311 4312 // ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46. 4313 // 4314 // Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 4315 func (_RequestableI *RequestableISession) ApplyRequestInChildChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 4316 return _RequestableI.Contract.ApplyRequestInChildChain(&_RequestableI.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 4317 } 4318 4319 // ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46. 4320 // 4321 // Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 4322 func (_RequestableI *RequestableITransactorSession) ApplyRequestInChildChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 4323 return _RequestableI.Contract.ApplyRequestInChildChain(&_RequestableI.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 4324 } 4325 4326 // ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308. 4327 // 4328 // Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 4329 func (_RequestableI *RequestableITransactor) ApplyRequestInRootChain(opts *bind.TransactOpts, isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 4330 return _RequestableI.contract.Transact(opts, "applyRequestInRootChain", isExit, requestId, requestor, trieKey, trieValue) 4331 } 4332 4333 // ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308. 4334 // 4335 // Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 4336 func (_RequestableI *RequestableISession) ApplyRequestInRootChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 4337 return _RequestableI.Contract.ApplyRequestInRootChain(&_RequestableI.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 4338 } 4339 4340 // ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308. 4341 // 4342 // Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 4343 func (_RequestableI *RequestableITransactorSession) ApplyRequestInRootChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 4344 return _RequestableI.Contract.ApplyRequestInRootChain(&_RequestableI.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 4345 } 4346 4347 // SafeMathABI is the input ABI used to generate the binding from. 4348 const SafeMathABI = "[]" 4349 4350 // SafeMathBin is the compiled bytecode used for deploying new contracts. 4351 var SafeMathBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582078d1ee36fbf693106287afc4e3d527969655a29fd174495c02497ad93dca957964736f6c634300050c0032" 4352 4353 // DeploySafeMath deploys a new Ethereum contract, binding an instance of SafeMath to it. 4354 func DeploySafeMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeMath, error) { 4355 parsed, err := abi.JSON(strings.NewReader(SafeMathABI)) 4356 if err != nil { 4357 return common.Address{}, nil, nil, err 4358 } 4359 4360 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SafeMathBin), backend) 4361 if err != nil { 4362 return common.Address{}, nil, nil, err 4363 } 4364 return address, tx, &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil 4365 } 4366 4367 // SafeMath is an auto generated Go binding around an Ethereum contract. 4368 type SafeMath struct { 4369 SafeMathCaller // Read-only binding to the contract 4370 SafeMathTransactor // Write-only binding to the contract 4371 SafeMathFilterer // Log filterer for contract events 4372 } 4373 4374 // SafeMathCaller is an auto generated read-only Go binding around an Ethereum contract. 4375 type SafeMathCaller struct { 4376 contract *bind.BoundContract // Generic contract wrapper for the low level calls 4377 } 4378 4379 // SafeMathTransactor is an auto generated write-only Go binding around an Ethereum contract. 4380 type SafeMathTransactor struct { 4381 contract *bind.BoundContract // Generic contract wrapper for the low level calls 4382 } 4383 4384 // SafeMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 4385 type SafeMathFilterer struct { 4386 contract *bind.BoundContract // Generic contract wrapper for the low level calls 4387 } 4388 4389 // SafeMathSession is an auto generated Go binding around an Ethereum contract, 4390 // with pre-set call and transact options. 4391 type SafeMathSession struct { 4392 Contract *SafeMath // Generic contract binding to set the session for 4393 CallOpts bind.CallOpts // Call options to use throughout this session 4394 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 4395 } 4396 4397 // SafeMathCallerSession is an auto generated read-only Go binding around an Ethereum contract, 4398 // with pre-set call options. 4399 type SafeMathCallerSession struct { 4400 Contract *SafeMathCaller // Generic contract caller binding to set the session for 4401 CallOpts bind.CallOpts // Call options to use throughout this session 4402 } 4403 4404 // SafeMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 4405 // with pre-set transact options. 4406 type SafeMathTransactorSession struct { 4407 Contract *SafeMathTransactor // Generic contract transactor binding to set the session for 4408 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 4409 } 4410 4411 // SafeMathRaw is an auto generated low-level Go binding around an Ethereum contract. 4412 type SafeMathRaw struct { 4413 Contract *SafeMath // Generic contract binding to access the raw methods on 4414 } 4415 4416 // SafeMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 4417 type SafeMathCallerRaw struct { 4418 Contract *SafeMathCaller // Generic read-only contract binding to access the raw methods on 4419 } 4420 4421 // SafeMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 4422 type SafeMathTransactorRaw struct { 4423 Contract *SafeMathTransactor // Generic write-only contract binding to access the raw methods on 4424 } 4425 4426 // NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract. 4427 func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error) { 4428 contract, err := bindSafeMath(address, backend, backend, backend) 4429 if err != nil { 4430 return nil, err 4431 } 4432 return &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil 4433 } 4434 4435 // NewSafeMathCaller creates a new read-only instance of SafeMath, bound to a specific deployed contract. 4436 func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error) { 4437 contract, err := bindSafeMath(address, caller, nil, nil) 4438 if err != nil { 4439 return nil, err 4440 } 4441 return &SafeMathCaller{contract: contract}, nil 4442 } 4443 4444 // NewSafeMathTransactor creates a new write-only instance of SafeMath, bound to a specific deployed contract. 4445 func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error) { 4446 contract, err := bindSafeMath(address, nil, transactor, nil) 4447 if err != nil { 4448 return nil, err 4449 } 4450 return &SafeMathTransactor{contract: contract}, nil 4451 } 4452 4453 // NewSafeMathFilterer creates a new log filterer instance of SafeMath, bound to a specific deployed contract. 4454 func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error) { 4455 contract, err := bindSafeMath(address, nil, nil, filterer) 4456 if err != nil { 4457 return nil, err 4458 } 4459 return &SafeMathFilterer{contract: contract}, nil 4460 } 4461 4462 // bindSafeMath binds a generic wrapper to an already deployed contract. 4463 func bindSafeMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 4464 parsed, err := abi.JSON(strings.NewReader(SafeMathABI)) 4465 if err != nil { 4466 return nil, err 4467 } 4468 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 4469 } 4470 4471 // Call invokes the (constant) contract method with params as input values and 4472 // sets the output to result. The result type might be a single field for simple 4473 // returns, a slice of interfaces for anonymous returns and a struct for named 4474 // returns. 4475 func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 4476 return _SafeMath.Contract.SafeMathCaller.contract.Call(opts, result, method, params...) 4477 } 4478 4479 // Transfer initiates a plain transaction to move funds to the contract, calling 4480 // its default method if one is available. 4481 func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 4482 return _SafeMath.Contract.SafeMathTransactor.contract.Transfer(opts) 4483 } 4484 4485 // Transact invokes the (paid) contract method with params as input values. 4486 func (_SafeMath *SafeMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 4487 return _SafeMath.Contract.SafeMathTransactor.contract.Transact(opts, method, params...) 4488 } 4489 4490 // Call invokes the (constant) contract method with params as input values and 4491 // sets the output to result. The result type might be a single field for simple 4492 // returns, a slice of interfaces for anonymous returns and a struct for named 4493 // returns. 4494 func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 4495 return _SafeMath.Contract.contract.Call(opts, result, method, params...) 4496 } 4497 4498 // Transfer initiates a plain transaction to move funds to the contract, calling 4499 // its default method if one is available. 4500 func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 4501 return _SafeMath.Contract.contract.Transfer(opts) 4502 } 4503 4504 // Transact invokes the (paid) contract method with params as input values. 4505 func (_SafeMath *SafeMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 4506 return _SafeMath.Contract.contract.Transact(opts, method, params...) 4507 } 4508 4509 // StandardTokenABI is the input ABI used to generate the binding from. 4510 const StandardTokenABI = "[{\"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\":\"_value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"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\":\"decreaseApproval\",\"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\":\"increaseApproval\",\"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\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 4511 4512 // StandardTokenFuncSigs maps the 4-byte function signature to its string representation. 4513 var StandardTokenFuncSigs = map[string]string{ 4514 "dd62ed3e": "allowance(address,address)", 4515 "095ea7b3": "approve(address,uint256)", 4516 "70a08231": "balanceOf(address)", 4517 "66188463": "decreaseApproval(address,uint256)", 4518 "d73dd623": "increaseApproval(address,uint256)", 4519 "18160ddd": "totalSupply()", 4520 "a9059cbb": "transfer(address,uint256)", 4521 "23b872dd": "transferFrom(address,address,uint256)", 4522 } 4523 4524 // StandardTokenBin is the compiled bytecode used for deploying new contracts. 4525 var StandardTokenBin = "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" 4526 4527 // DeployStandardToken deploys a new Ethereum contract, binding an instance of StandardToken to it. 4528 func DeployStandardToken(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *StandardToken, error) { 4529 parsed, err := abi.JSON(strings.NewReader(StandardTokenABI)) 4530 if err != nil { 4531 return common.Address{}, nil, nil, err 4532 } 4533 4534 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(StandardTokenBin), backend) 4535 if err != nil { 4536 return common.Address{}, nil, nil, err 4537 } 4538 return address, tx, &StandardToken{StandardTokenCaller: StandardTokenCaller{contract: contract}, StandardTokenTransactor: StandardTokenTransactor{contract: contract}, StandardTokenFilterer: StandardTokenFilterer{contract: contract}}, nil 4539 } 4540 4541 // StandardToken is an auto generated Go binding around an Ethereum contract. 4542 type StandardToken struct { 4543 StandardTokenCaller // Read-only binding to the contract 4544 StandardTokenTransactor // Write-only binding to the contract 4545 StandardTokenFilterer // Log filterer for contract events 4546 } 4547 4548 // StandardTokenCaller is an auto generated read-only Go binding around an Ethereum contract. 4549 type StandardTokenCaller struct { 4550 contract *bind.BoundContract // Generic contract wrapper for the low level calls 4551 } 4552 4553 // StandardTokenTransactor is an auto generated write-only Go binding around an Ethereum contract. 4554 type StandardTokenTransactor struct { 4555 contract *bind.BoundContract // Generic contract wrapper for the low level calls 4556 } 4557 4558 // StandardTokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 4559 type StandardTokenFilterer struct { 4560 contract *bind.BoundContract // Generic contract wrapper for the low level calls 4561 } 4562 4563 // StandardTokenSession is an auto generated Go binding around an Ethereum contract, 4564 // with pre-set call and transact options. 4565 type StandardTokenSession struct { 4566 Contract *StandardToken // Generic contract binding to set the session for 4567 CallOpts bind.CallOpts // Call options to use throughout this session 4568 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 4569 } 4570 4571 // StandardTokenCallerSession is an auto generated read-only Go binding around an Ethereum contract, 4572 // with pre-set call options. 4573 type StandardTokenCallerSession struct { 4574 Contract *StandardTokenCaller // Generic contract caller binding to set the session for 4575 CallOpts bind.CallOpts // Call options to use throughout this session 4576 } 4577 4578 // StandardTokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 4579 // with pre-set transact options. 4580 type StandardTokenTransactorSession struct { 4581 Contract *StandardTokenTransactor // Generic contract transactor binding to set the session for 4582 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 4583 } 4584 4585 // StandardTokenRaw is an auto generated low-level Go binding around an Ethereum contract. 4586 type StandardTokenRaw struct { 4587 Contract *StandardToken // Generic contract binding to access the raw methods on 4588 } 4589 4590 // StandardTokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 4591 type StandardTokenCallerRaw struct { 4592 Contract *StandardTokenCaller // Generic read-only contract binding to access the raw methods on 4593 } 4594 4595 // StandardTokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 4596 type StandardTokenTransactorRaw struct { 4597 Contract *StandardTokenTransactor // Generic write-only contract binding to access the raw methods on 4598 } 4599 4600 // NewStandardToken creates a new instance of StandardToken, bound to a specific deployed contract. 4601 func NewStandardToken(address common.Address, backend bind.ContractBackend) (*StandardToken, error) { 4602 contract, err := bindStandardToken(address, backend, backend, backend) 4603 if err != nil { 4604 return nil, err 4605 } 4606 return &StandardToken{StandardTokenCaller: StandardTokenCaller{contract: contract}, StandardTokenTransactor: StandardTokenTransactor{contract: contract}, StandardTokenFilterer: StandardTokenFilterer{contract: contract}}, nil 4607 } 4608 4609 // NewStandardTokenCaller creates a new read-only instance of StandardToken, bound to a specific deployed contract. 4610 func NewStandardTokenCaller(address common.Address, caller bind.ContractCaller) (*StandardTokenCaller, error) { 4611 contract, err := bindStandardToken(address, caller, nil, nil) 4612 if err != nil { 4613 return nil, err 4614 } 4615 return &StandardTokenCaller{contract: contract}, nil 4616 } 4617 4618 // NewStandardTokenTransactor creates a new write-only instance of StandardToken, bound to a specific deployed contract. 4619 func NewStandardTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*StandardTokenTransactor, error) { 4620 contract, err := bindStandardToken(address, nil, transactor, nil) 4621 if err != nil { 4622 return nil, err 4623 } 4624 return &StandardTokenTransactor{contract: contract}, nil 4625 } 4626 4627 // NewStandardTokenFilterer creates a new log filterer instance of StandardToken, bound to a specific deployed contract. 4628 func NewStandardTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*StandardTokenFilterer, error) { 4629 contract, err := bindStandardToken(address, nil, nil, filterer) 4630 if err != nil { 4631 return nil, err 4632 } 4633 return &StandardTokenFilterer{contract: contract}, nil 4634 } 4635 4636 // bindStandardToken binds a generic wrapper to an already deployed contract. 4637 func bindStandardToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 4638 parsed, err := abi.JSON(strings.NewReader(StandardTokenABI)) 4639 if err != nil { 4640 return nil, err 4641 } 4642 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 4643 } 4644 4645 // Call invokes the (constant) contract method with params as input values and 4646 // sets the output to result. The result type might be a single field for simple 4647 // returns, a slice of interfaces for anonymous returns and a struct for named 4648 // returns. 4649 func (_StandardToken *StandardTokenRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 4650 return _StandardToken.Contract.StandardTokenCaller.contract.Call(opts, result, method, params...) 4651 } 4652 4653 // Transfer initiates a plain transaction to move funds to the contract, calling 4654 // its default method if one is available. 4655 func (_StandardToken *StandardTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 4656 return _StandardToken.Contract.StandardTokenTransactor.contract.Transfer(opts) 4657 } 4658 4659 // Transact invokes the (paid) contract method with params as input values. 4660 func (_StandardToken *StandardTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 4661 return _StandardToken.Contract.StandardTokenTransactor.contract.Transact(opts, method, params...) 4662 } 4663 4664 // Call invokes the (constant) contract method with params as input values and 4665 // sets the output to result. The result type might be a single field for simple 4666 // returns, a slice of interfaces for anonymous returns and a struct for named 4667 // returns. 4668 func (_StandardToken *StandardTokenCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 4669 return _StandardToken.Contract.contract.Call(opts, result, method, params...) 4670 } 4671 4672 // Transfer initiates a plain transaction to move funds to the contract, calling 4673 // its default method if one is available. 4674 func (_StandardToken *StandardTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 4675 return _StandardToken.Contract.contract.Transfer(opts) 4676 } 4677 4678 // Transact invokes the (paid) contract method with params as input values. 4679 func (_StandardToken *StandardTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 4680 return _StandardToken.Contract.contract.Transact(opts, method, params...) 4681 } 4682 4683 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 4684 // 4685 // Solidity: function allowance(address _owner, address _spender) constant returns(uint256) 4686 func (_StandardToken *StandardTokenCaller) Allowance(opts *bind.CallOpts, _owner common.Address, _spender common.Address) (*big.Int, error) { 4687 var ( 4688 ret0 = new(*big.Int) 4689 ) 4690 out := ret0 4691 err := _StandardToken.contract.Call(opts, out, "allowance", _owner, _spender) 4692 return *ret0, err 4693 } 4694 4695 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 4696 // 4697 // Solidity: function allowance(address _owner, address _spender) constant returns(uint256) 4698 func (_StandardToken *StandardTokenSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) { 4699 return _StandardToken.Contract.Allowance(&_StandardToken.CallOpts, _owner, _spender) 4700 } 4701 4702 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 4703 // 4704 // Solidity: function allowance(address _owner, address _spender) constant returns(uint256) 4705 func (_StandardToken *StandardTokenCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) { 4706 return _StandardToken.Contract.Allowance(&_StandardToken.CallOpts, _owner, _spender) 4707 } 4708 4709 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 4710 // 4711 // Solidity: function balanceOf(address _owner) constant returns(uint256) 4712 func (_StandardToken *StandardTokenCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) { 4713 var ( 4714 ret0 = new(*big.Int) 4715 ) 4716 out := ret0 4717 err := _StandardToken.contract.Call(opts, out, "balanceOf", _owner) 4718 return *ret0, err 4719 } 4720 4721 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 4722 // 4723 // Solidity: function balanceOf(address _owner) constant returns(uint256) 4724 func (_StandardToken *StandardTokenSession) BalanceOf(_owner common.Address) (*big.Int, error) { 4725 return _StandardToken.Contract.BalanceOf(&_StandardToken.CallOpts, _owner) 4726 } 4727 4728 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 4729 // 4730 // Solidity: function balanceOf(address _owner) constant returns(uint256) 4731 func (_StandardToken *StandardTokenCallerSession) BalanceOf(_owner common.Address) (*big.Int, error) { 4732 return _StandardToken.Contract.BalanceOf(&_StandardToken.CallOpts, _owner) 4733 } 4734 4735 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 4736 // 4737 // Solidity: function totalSupply() constant returns(uint256) 4738 func (_StandardToken *StandardTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 4739 var ( 4740 ret0 = new(*big.Int) 4741 ) 4742 out := ret0 4743 err := _StandardToken.contract.Call(opts, out, "totalSupply") 4744 return *ret0, err 4745 } 4746 4747 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 4748 // 4749 // Solidity: function totalSupply() constant returns(uint256) 4750 func (_StandardToken *StandardTokenSession) TotalSupply() (*big.Int, error) { 4751 return _StandardToken.Contract.TotalSupply(&_StandardToken.CallOpts) 4752 } 4753 4754 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 4755 // 4756 // Solidity: function totalSupply() constant returns(uint256) 4757 func (_StandardToken *StandardTokenCallerSession) TotalSupply() (*big.Int, error) { 4758 return _StandardToken.Contract.TotalSupply(&_StandardToken.CallOpts) 4759 } 4760 4761 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 4762 // 4763 // Solidity: function approve(address _spender, uint256 _value) returns(bool) 4764 func (_StandardToken *StandardTokenTransactor) Approve(opts *bind.TransactOpts, _spender common.Address, _value *big.Int) (*types.Transaction, error) { 4765 return _StandardToken.contract.Transact(opts, "approve", _spender, _value) 4766 } 4767 4768 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 4769 // 4770 // Solidity: function approve(address _spender, uint256 _value) returns(bool) 4771 func (_StandardToken *StandardTokenSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) { 4772 return _StandardToken.Contract.Approve(&_StandardToken.TransactOpts, _spender, _value) 4773 } 4774 4775 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 4776 // 4777 // Solidity: function approve(address _spender, uint256 _value) returns(bool) 4778 func (_StandardToken *StandardTokenTransactorSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) { 4779 return _StandardToken.Contract.Approve(&_StandardToken.TransactOpts, _spender, _value) 4780 } 4781 4782 // DecreaseApproval is a paid mutator transaction binding the contract method 0x66188463. 4783 // 4784 // Solidity: function decreaseApproval(address _spender, uint256 _subtractedValue) returns(bool) 4785 func (_StandardToken *StandardTokenTransactor) DecreaseApproval(opts *bind.TransactOpts, _spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error) { 4786 return _StandardToken.contract.Transact(opts, "decreaseApproval", _spender, _subtractedValue) 4787 } 4788 4789 // DecreaseApproval is a paid mutator transaction binding the contract method 0x66188463. 4790 // 4791 // Solidity: function decreaseApproval(address _spender, uint256 _subtractedValue) returns(bool) 4792 func (_StandardToken *StandardTokenSession) DecreaseApproval(_spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error) { 4793 return _StandardToken.Contract.DecreaseApproval(&_StandardToken.TransactOpts, _spender, _subtractedValue) 4794 } 4795 4796 // DecreaseApproval is a paid mutator transaction binding the contract method 0x66188463. 4797 // 4798 // Solidity: function decreaseApproval(address _spender, uint256 _subtractedValue) returns(bool) 4799 func (_StandardToken *StandardTokenTransactorSession) DecreaseApproval(_spender common.Address, _subtractedValue *big.Int) (*types.Transaction, error) { 4800 return _StandardToken.Contract.DecreaseApproval(&_StandardToken.TransactOpts, _spender, _subtractedValue) 4801 } 4802 4803 // IncreaseApproval is a paid mutator transaction binding the contract method 0xd73dd623. 4804 // 4805 // Solidity: function increaseApproval(address _spender, uint256 _addedValue) returns(bool) 4806 func (_StandardToken *StandardTokenTransactor) IncreaseApproval(opts *bind.TransactOpts, _spender common.Address, _addedValue *big.Int) (*types.Transaction, error) { 4807 return _StandardToken.contract.Transact(opts, "increaseApproval", _spender, _addedValue) 4808 } 4809 4810 // IncreaseApproval is a paid mutator transaction binding the contract method 0xd73dd623. 4811 // 4812 // Solidity: function increaseApproval(address _spender, uint256 _addedValue) returns(bool) 4813 func (_StandardToken *StandardTokenSession) IncreaseApproval(_spender common.Address, _addedValue *big.Int) (*types.Transaction, error) { 4814 return _StandardToken.Contract.IncreaseApproval(&_StandardToken.TransactOpts, _spender, _addedValue) 4815 } 4816 4817 // IncreaseApproval is a paid mutator transaction binding the contract method 0xd73dd623. 4818 // 4819 // Solidity: function increaseApproval(address _spender, uint256 _addedValue) returns(bool) 4820 func (_StandardToken *StandardTokenTransactorSession) IncreaseApproval(_spender common.Address, _addedValue *big.Int) (*types.Transaction, error) { 4821 return _StandardToken.Contract.IncreaseApproval(&_StandardToken.TransactOpts, _spender, _addedValue) 4822 } 4823 4824 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 4825 // 4826 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 4827 func (_StandardToken *StandardTokenTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error) { 4828 return _StandardToken.contract.Transact(opts, "transfer", _to, _value) 4829 } 4830 4831 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 4832 // 4833 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 4834 func (_StandardToken *StandardTokenSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { 4835 return _StandardToken.Contract.Transfer(&_StandardToken.TransactOpts, _to, _value) 4836 } 4837 4838 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 4839 // 4840 // Solidity: function transfer(address _to, uint256 _value) returns(bool) 4841 func (_StandardToken *StandardTokenTransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { 4842 return _StandardToken.Contract.Transfer(&_StandardToken.TransactOpts, _to, _value) 4843 } 4844 4845 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 4846 // 4847 // Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool) 4848 func (_StandardToken *StandardTokenTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { 4849 return _StandardToken.contract.Transact(opts, "transferFrom", _from, _to, _value) 4850 } 4851 4852 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 4853 // 4854 // Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool) 4855 func (_StandardToken *StandardTokenSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { 4856 return _StandardToken.Contract.TransferFrom(&_StandardToken.TransactOpts, _from, _to, _value) 4857 } 4858 4859 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 4860 // 4861 // Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool) 4862 func (_StandardToken *StandardTokenTransactorSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { 4863 return _StandardToken.Contract.TransferFrom(&_StandardToken.TransactOpts, _from, _to, _value) 4864 } 4865 4866 // StandardTokenApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the StandardToken contract. 4867 type StandardTokenApprovalIterator struct { 4868 Event *StandardTokenApproval // Event containing the contract specifics and raw log 4869 4870 contract *bind.BoundContract // Generic contract to use for unpacking event data 4871 event string // Event name to use for unpacking event data 4872 4873 logs chan types.Log // Log channel receiving the found contract events 4874 sub ethereum.Subscription // Subscription for errors, completion and termination 4875 done bool // Whether the subscription completed delivering logs 4876 fail error // Occurred error to stop iteration 4877 } 4878 4879 // Next advances the iterator to the subsequent event, returning whether there 4880 // are any more events found. In case of a retrieval or parsing error, false is 4881 // returned and Error() can be queried for the exact failure. 4882 func (it *StandardTokenApprovalIterator) Next() bool { 4883 // If the iterator failed, stop iterating 4884 if it.fail != nil { 4885 return false 4886 } 4887 // If the iterator completed, deliver directly whatever's available 4888 if it.done { 4889 select { 4890 case log := <-it.logs: 4891 it.Event = new(StandardTokenApproval) 4892 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4893 it.fail = err 4894 return false 4895 } 4896 it.Event.Raw = log 4897 return true 4898 4899 default: 4900 return false 4901 } 4902 } 4903 // Iterator still in progress, wait for either a data or an error event 4904 select { 4905 case log := <-it.logs: 4906 it.Event = new(StandardTokenApproval) 4907 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4908 it.fail = err 4909 return false 4910 } 4911 it.Event.Raw = log 4912 return true 4913 4914 case err := <-it.sub.Err(): 4915 it.done = true 4916 it.fail = err 4917 return it.Next() 4918 } 4919 } 4920 4921 // Error returns any retrieval or parsing error occurred during filtering. 4922 func (it *StandardTokenApprovalIterator) Error() error { 4923 return it.fail 4924 } 4925 4926 // Close terminates the iteration process, releasing any pending underlying 4927 // resources. 4928 func (it *StandardTokenApprovalIterator) Close() error { 4929 it.sub.Unsubscribe() 4930 return nil 4931 } 4932 4933 // StandardTokenApproval represents a Approval event raised by the StandardToken contract. 4934 type StandardTokenApproval struct { 4935 Owner common.Address 4936 Spender common.Address 4937 Value *big.Int 4938 Raw types.Log // Blockchain specific contextual infos 4939 } 4940 4941 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 4942 // 4943 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 4944 func (_StandardToken *StandardTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*StandardTokenApprovalIterator, error) { 4945 4946 var ownerRule []interface{} 4947 for _, ownerItem := range owner { 4948 ownerRule = append(ownerRule, ownerItem) 4949 } 4950 var spenderRule []interface{} 4951 for _, spenderItem := range spender { 4952 spenderRule = append(spenderRule, spenderItem) 4953 } 4954 4955 logs, sub, err := _StandardToken.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 4956 if err != nil { 4957 return nil, err 4958 } 4959 return &StandardTokenApprovalIterator{contract: _StandardToken.contract, event: "Approval", logs: logs, sub: sub}, nil 4960 } 4961 4962 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 4963 // 4964 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 4965 func (_StandardToken *StandardTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *StandardTokenApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 4966 4967 var ownerRule []interface{} 4968 for _, ownerItem := range owner { 4969 ownerRule = append(ownerRule, ownerItem) 4970 } 4971 var spenderRule []interface{} 4972 for _, spenderItem := range spender { 4973 spenderRule = append(spenderRule, spenderItem) 4974 } 4975 4976 logs, sub, err := _StandardToken.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 4977 if err != nil { 4978 return nil, err 4979 } 4980 return event.NewSubscription(func(quit <-chan struct{}) error { 4981 defer sub.Unsubscribe() 4982 for { 4983 select { 4984 case log := <-logs: 4985 // New log arrived, parse the event and forward to the user 4986 event := new(StandardTokenApproval) 4987 if err := _StandardToken.contract.UnpackLog(event, "Approval", log); err != nil { 4988 return err 4989 } 4990 event.Raw = log 4991 4992 select { 4993 case sink <- event: 4994 case err := <-sub.Err(): 4995 return err 4996 case <-quit: 4997 return nil 4998 } 4999 case err := <-sub.Err(): 5000 return err 5001 case <-quit: 5002 return nil 5003 } 5004 } 5005 }), nil 5006 } 5007 5008 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 5009 // 5010 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 5011 func (_StandardToken *StandardTokenFilterer) ParseApproval(log types.Log) (*StandardTokenApproval, error) { 5012 event := new(StandardTokenApproval) 5013 if err := _StandardToken.contract.UnpackLog(event, "Approval", log); err != nil { 5014 return nil, err 5015 } 5016 return event, nil 5017 } 5018 5019 // StandardTokenTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the StandardToken contract. 5020 type StandardTokenTransferIterator struct { 5021 Event *StandardTokenTransfer // Event containing the contract specifics and raw log 5022 5023 contract *bind.BoundContract // Generic contract to use for unpacking event data 5024 event string // Event name to use for unpacking event data 5025 5026 logs chan types.Log // Log channel receiving the found contract events 5027 sub ethereum.Subscription // Subscription for errors, completion and termination 5028 done bool // Whether the subscription completed delivering logs 5029 fail error // Occurred error to stop iteration 5030 } 5031 5032 // Next advances the iterator to the subsequent event, returning whether there 5033 // are any more events found. In case of a retrieval or parsing error, false is 5034 // returned and Error() can be queried for the exact failure. 5035 func (it *StandardTokenTransferIterator) Next() bool { 5036 // If the iterator failed, stop iterating 5037 if it.fail != nil { 5038 return false 5039 } 5040 // If the iterator completed, deliver directly whatever's available 5041 if it.done { 5042 select { 5043 case log := <-it.logs: 5044 it.Event = new(StandardTokenTransfer) 5045 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 5046 it.fail = err 5047 return false 5048 } 5049 it.Event.Raw = log 5050 return true 5051 5052 default: 5053 return false 5054 } 5055 } 5056 // Iterator still in progress, wait for either a data or an error event 5057 select { 5058 case log := <-it.logs: 5059 it.Event = new(StandardTokenTransfer) 5060 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 5061 it.fail = err 5062 return false 5063 } 5064 it.Event.Raw = log 5065 return true 5066 5067 case err := <-it.sub.Err(): 5068 it.done = true 5069 it.fail = err 5070 return it.Next() 5071 } 5072 } 5073 5074 // Error returns any retrieval or parsing error occurred during filtering. 5075 func (it *StandardTokenTransferIterator) Error() error { 5076 return it.fail 5077 } 5078 5079 // Close terminates the iteration process, releasing any pending underlying 5080 // resources. 5081 func (it *StandardTokenTransferIterator) Close() error { 5082 it.sub.Unsubscribe() 5083 return nil 5084 } 5085 5086 // StandardTokenTransfer represents a Transfer event raised by the StandardToken contract. 5087 type StandardTokenTransfer struct { 5088 From common.Address 5089 To common.Address 5090 Value *big.Int 5091 Raw types.Log // Blockchain specific contextual infos 5092 } 5093 5094 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 5095 // 5096 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 5097 func (_StandardToken *StandardTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*StandardTokenTransferIterator, error) { 5098 5099 var fromRule []interface{} 5100 for _, fromItem := range from { 5101 fromRule = append(fromRule, fromItem) 5102 } 5103 var toRule []interface{} 5104 for _, toItem := range to { 5105 toRule = append(toRule, toItem) 5106 } 5107 5108 logs, sub, err := _StandardToken.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 5109 if err != nil { 5110 return nil, err 5111 } 5112 return &StandardTokenTransferIterator{contract: _StandardToken.contract, event: "Transfer", logs: logs, sub: sub}, nil 5113 } 5114 5115 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 5116 // 5117 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 5118 func (_StandardToken *StandardTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *StandardTokenTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 5119 5120 var fromRule []interface{} 5121 for _, fromItem := range from { 5122 fromRule = append(fromRule, fromItem) 5123 } 5124 var toRule []interface{} 5125 for _, toItem := range to { 5126 toRule = append(toRule, toItem) 5127 } 5128 5129 logs, sub, err := _StandardToken.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 5130 if err != nil { 5131 return nil, err 5132 } 5133 return event.NewSubscription(func(quit <-chan struct{}) error { 5134 defer sub.Unsubscribe() 5135 for { 5136 select { 5137 case log := <-logs: 5138 // New log arrived, parse the event and forward to the user 5139 event := new(StandardTokenTransfer) 5140 if err := _StandardToken.contract.UnpackLog(event, "Transfer", log); err != nil { 5141 return err 5142 } 5143 event.Raw = log 5144 5145 select { 5146 case sink <- event: 5147 case err := <-sub.Err(): 5148 return err 5149 case <-quit: 5150 return nil 5151 } 5152 case err := <-sub.Err(): 5153 return err 5154 case <-quit: 5155 return nil 5156 } 5157 } 5158 }), nil 5159 } 5160 5161 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 5162 // 5163 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 5164 func (_StandardToken *StandardTokenFilterer) ParseTransfer(log types.Log) (*StandardTokenTransfer, error) { 5165 event := new(StandardTokenTransfer) 5166 if err := _StandardToken.contract.UnpackLog(event, "Transfer", log); err != nil { 5167 return nil, err 5168 } 5169 return event, nil 5170 }