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 = "0x608060405234801561001057600080fd5b50604051610f99380380610f998339818101604052604081101561003357600080fd5b5080516020909101516003805461ff0019166101009315159390930292909217909155600480546001600160a01b0319166001600160a01b03909216919091179055610f15806100846000396000f3fe608060405234801561001057600080fd5b50600436106101215760003560e01c80637b929c27116100ad578063b9e59d0911610071578063b9e59d09146103f0578063bcc7874d14610496578063d73dd623146104ba578063dd62ed3e146104e6578063fc0c546a1461051457610121565b80637b929c27146102e6578063a9059cbb146102ee578063a9f793081461031a578063b18fcfdf146103ad578063b6b55f25146103d357610121565b806319ab453c116100f457806319ab453c1461021b57806323b872dd146102415780632e1a7d4d14610277578063661884631461029457806370a08231146102c057610121565b8063095ea7b314610126578063141ecf4614610166578063158ef93e146101f957806318160ddd14610201575b600080fd5b6101526004803603604081101561013c57600080fd5b506001600160a01b03813516906020013561051c565b604080519115158252519081900360200190f35b610152600480360360a081101561017c57600080fd5b81351515916020810135916001600160a01b036040830135169160608101359181019060a0810160808201356401000000008111156101ba57600080fd5b8201836020820111156101cc57600080fd5b803590602001918460018302840111640100000000831117156101ee57600080fd5b509092509050610582565b610152610677565b610209610680565b60408051918252519081900360200190f35b6101526004803603602081101561023157600080fd5b50356001600160a01b0316610686565b6101526004803603606081101561025757600080fd5b506001600160a01b038135811691602081013590911690604001356106cc565b6101526004803603602081101561028d57600080fd5b503561082d565b610152600480360360408110156102aa57600080fd5b506001600160a01b038135169060200135610916565b610209600480360360208110156102d657600080fd5b50356001600160a01b0316610a05565b610152610a20565b6101526004803603604081101561030457600080fd5b506001600160a01b038135169060200135610a2e565b610152600480360360a081101561033057600080fd5b81351515916020810135916001600160a01b036040830135169160608101359181019060a08101608082013564010000000081111561036e57600080fd5b82018360208201111561038057600080fd5b803590602001918460018302840111640100000000831117156103a257600080fd5b509092509050610af9565b610209600480360360208110156103c357600080fd5b50356001600160a01b0316610b99565b610152600480360360208110156103e957600080fd5b5035610bdb565b6102096004803603602081101561040657600080fd5b81019060208101813564010000000081111561042157600080fd5b82018360208201111561043357600080fd5b8035906020019184600183028401116401000000008311171561045557600080fd5b91908080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250929550610c8d945050505050565b61049e610ca5565b604080516001600160a01b039092168252519081900360200190f35b610152600480360360408110156104d057600080fd5b506001600160a01b038135169060200135610cba565b610209600480360360408110156104fc57600080fd5b506001600160a01b0381358116916020013516610d53565b61049e610d7e565b3360008181526002602090815260408083206001600160a01b038716808552908352818420869055815186815291519394909390927f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925928290030190a350600192915050565b600354600090610100900460ff1680610599575033155b6105a257600080fd5b6105ab85610b99565b84146105b657600080fd5b60006105f784848080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250610c8d92505050565b9050871561060e576106098682610d8d565b610618565b6106188682610e18565b6040805189151581526001600160a01b03881660208201528082018790526060810183905290517f4b0c23cd90bac23cdaa0958fbd0306f53e20cd5e65676d21b9ceb109784e15b89181900360800190a1506001979650505050505050565b60035460ff1681565b60015490565b60035460009060ff161561069957600080fd5b6003805460ff196001600160a01b03909416620100000262010000600160b01b0319909116179290921660011790915590565b6001600160a01b0383166000908152602081905260408120548211156106f157600080fd5b6001600160a01b038416600090815260026020908152604080832033845290915290205482111561072157600080fd5b6001600160a01b03831661073457600080fd5b6001600160a01b03841660009081526020819052604090205461075d908363ffffffff610e9b16565b6001600160a01b038086166000908152602081905260408082209390935590851681522054610792908363ffffffff610ead16565b6001600160a01b038085166000908152602081815260408083209490945591871681526002825282812033825290915220546107d4908363ffffffff610e9b16565b6001600160a01b0380861660008181526002602090815260408083203384528252918290209490945580518681529051928716939192600080516020610ec1833981519152929181900390910190a35060019392505050565b60035460009060ff1661083f57600080fd5b6108493383610d8d565b604080513381526020810184905281517f7084f5476618d8e60b11ef0d7d3f06914655adb8793e28ff7f018d4c76d505d5929181900390910190a1600480546040805163a9059cbb60e01b8152339381019390935260248301859052516001600160a01b039091169163a9059cbb9160448083019260209291908290030181600087803b1580156108d957600080fd5b505af11580156108ed573d6000803e3d6000fd5b505050506040513d602081101561090357600080fd5b505161090e57600080fd5b506001919050565b3360009081526002602090815260408083206001600160a01b038616845290915281205480831061096a573360009081526002602090815260408083206001600160a01b038816845290915281205561099f565b61097a818463ffffffff610e9b16565b3360009081526002602090815260408083206001600160a01b03891684529091529020555b3360008181526002602090815260408083206001600160a01b0389168085529083529281902054815190815290519293927f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925929181900390910190a35060019392505050565b6001600160a01b031660009081526020819052604090205490565b600354610100900460ff1681565b33600090815260208190526040812054821115610a4a57600080fd5b6001600160a01b038316610a5d57600080fd5b33600090815260208190526040902054610a7d908363ffffffff610e9b16565b33600090815260208190526040808220929092556001600160a01b03851681522054610aaf908363ffffffff610ead16565b6001600160a01b03841660008181526020818152604091829020939093558051858152905191923392600080516020610ec18339815191529281900390910190a350600192915050565b60035460009060ff16610b0b57600080fd5b6003546201000090046001600160a01b03163314610b2857600080fd5b610b3185610b99565b8414610b3c57600080fd5b6000610b7d84848080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250610c8d92505050565b90508715610b8f576106098682610e18565b6106188682610d8d565b60408051600060208083019190915260609390931b6bffffffffffffffffffffffff191681830152815180820360340181526054909101909152805191012090565b60035460009060ff16610bed57600080fd5b610bf73383610e18565b604080513381526020810184905281517f46fc0825df492a7a7f1fb1b690f6912ecb69575484fbb24be0f398ae70d97db4929181900390910190a160048054604080516323b872dd60e01b8152339381019390935230602484015260448301859052516001600160a01b03909116916323b872dd9160648083019260209291908290030181600087803b1580156108d957600080fd5b60008151602014610c9d57600080fd5b506020015190565b6003546201000090046001600160a01b031681565b3360009081526002602090815260408083206001600160a01b0386168452909152812054610cee908363ffffffff610ead16565b3360008181526002602090815260408083206001600160a01b0389168085529083529281902085905580519485525191937f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925929081900390910190a350600192915050565b6001600160a01b03918216600090815260026020908152604080832093909416825291909152205490565b6004546001600160a01b031681565b6001600160a01b038216600090815260208190526040902054610db6908263ffffffff610e9b16565b6001600160a01b038316600090815260208190526040902055600154610de2908263ffffffff610e9b16565b6001556040805182815290516000916001600160a01b03851691600080516020610ec18339815191529181900360200190a35050565b600154610e2b908263ffffffff610ead16565b6001556001600160a01b038216600090815260208190526040902054610e57908263ffffffff610ead16565b6001600160a01b038316600081815260208181526040808320949094558351858152935192939192600080516020610ec18339815191529281900390910190a35050565b600082821115610ea757fe5b50900390565b81810182811015610eba57fe5b9291505056feddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3efa265627a7a7231582040b5851a436d3e037e788492570d881fd535c04259ebd9807b70b2ac62dd79a964736f6c634300050c0032"
  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  }