github.com/Onther-Tech/plasma-evm@v0.0.0-rc7.7/contracts/plasma/token/token.go (about)

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