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

     1  // Code generated - DO NOT EDIT.
     2  // This file is a generated binding and any manual changes will be lost.
     3  
     4  package ton
     5  
     6  import (
     7  	"math/big"
     8  	"strings"
     9  
    10  	"github.com/Onther-Tech/plasma-evm"
    11  	"github.com/Onther-Tech/plasma-evm/accounts/abi"
    12  	"github.com/Onther-Tech/plasma-evm/accounts/abi/bind"
    13  	"github.com/Onther-Tech/plasma-evm/common"
    14  	"github.com/Onther-Tech/plasma-evm/core/types"
    15  	"github.com/Onther-Tech/plasma-evm/event"
    16  )
    17  
    18  // Reference imports to suppress errors if they are not otherwise used.
    19  var (
    20  	_ = big.NewInt
    21  	_ = strings.NewReader
    22  	_ = ethereum.NotFound
    23  	_ = abi.U256
    24  	_ = bind.Bind
    25  	_ = common.Big1
    26  	_ = types.BloomLookup
    27  	_ = event.NewSubscription
    28  )
    29  
    30  // AuthControllerABI is the input ABI used to generate the binding from.
    31  const AuthControllerABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
    32  
    33  // AuthControllerFuncSigs maps the 4-byte function signature to its string representation.
    34  var AuthControllerFuncSigs = map[string]string{
    35  	"8f32d59b": "isOwner()",
    36  	"8da5cb5b": "owner()",
    37  	"5f112c68": "renounceMinter(address)",
    38  	"715018a6": "renounceOwnership()",
    39  	"38bf3cfa": "renounceOwnership(address)",
    40  	"41eb24bb": "renouncePauser(address)",
    41  	"f2fde38b": "transferOwnership(address)",
    42  	"6d435421": "transferOwnership(address,address)",
    43  }
    44  
    45  // AuthControllerBin is the compiled bytecode used for deploying new contracts.
    46  var AuthControllerBin = "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"
    47  
    48  // DeployAuthController deploys a new Ethereum contract, binding an instance of AuthController to it.
    49  func DeployAuthController(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *AuthController, error) {
    50  	parsed, err := abi.JSON(strings.NewReader(AuthControllerABI))
    51  	if err != nil {
    52  		return common.Address{}, nil, nil, err
    53  	}
    54  
    55  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(AuthControllerBin), backend)
    56  	if err != nil {
    57  		return common.Address{}, nil, nil, err
    58  	}
    59  	return address, tx, &AuthController{AuthControllerCaller: AuthControllerCaller{contract: contract}, AuthControllerTransactor: AuthControllerTransactor{contract: contract}, AuthControllerFilterer: AuthControllerFilterer{contract: contract}}, nil
    60  }
    61  
    62  // AuthController is an auto generated Go binding around an Ethereum contract.
    63  type AuthController struct {
    64  	AuthControllerCaller     // Read-only binding to the contract
    65  	AuthControllerTransactor // Write-only binding to the contract
    66  	AuthControllerFilterer   // Log filterer for contract events
    67  }
    68  
    69  // AuthControllerCaller is an auto generated read-only Go binding around an Ethereum contract.
    70  type AuthControllerCaller struct {
    71  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
    72  }
    73  
    74  // AuthControllerTransactor is an auto generated write-only Go binding around an Ethereum contract.
    75  type AuthControllerTransactor struct {
    76  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
    77  }
    78  
    79  // AuthControllerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
    80  type AuthControllerFilterer struct {
    81  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
    82  }
    83  
    84  // AuthControllerSession is an auto generated Go binding around an Ethereum contract,
    85  // with pre-set call and transact options.
    86  type AuthControllerSession struct {
    87  	Contract     *AuthController   // Generic contract binding to set the session for
    88  	CallOpts     bind.CallOpts     // Call options to use throughout this session
    89  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
    90  }
    91  
    92  // AuthControllerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
    93  // with pre-set call options.
    94  type AuthControllerCallerSession struct {
    95  	Contract *AuthControllerCaller // Generic contract caller binding to set the session for
    96  	CallOpts bind.CallOpts         // Call options to use throughout this session
    97  }
    98  
    99  // AuthControllerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
   100  // with pre-set transact options.
   101  type AuthControllerTransactorSession struct {
   102  	Contract     *AuthControllerTransactor // Generic contract transactor binding to set the session for
   103  	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
   104  }
   105  
   106  // AuthControllerRaw is an auto generated low-level Go binding around an Ethereum contract.
   107  type AuthControllerRaw struct {
   108  	Contract *AuthController // Generic contract binding to access the raw methods on
   109  }
   110  
   111  // AuthControllerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
   112  type AuthControllerCallerRaw struct {
   113  	Contract *AuthControllerCaller // Generic read-only contract binding to access the raw methods on
   114  }
   115  
   116  // AuthControllerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
   117  type AuthControllerTransactorRaw struct {
   118  	Contract *AuthControllerTransactor // Generic write-only contract binding to access the raw methods on
   119  }
   120  
   121  // NewAuthController creates a new instance of AuthController, bound to a specific deployed contract.
   122  func NewAuthController(address common.Address, backend bind.ContractBackend) (*AuthController, error) {
   123  	contract, err := bindAuthController(address, backend, backend, backend)
   124  	if err != nil {
   125  		return nil, err
   126  	}
   127  	return &AuthController{AuthControllerCaller: AuthControllerCaller{contract: contract}, AuthControllerTransactor: AuthControllerTransactor{contract: contract}, AuthControllerFilterer: AuthControllerFilterer{contract: contract}}, nil
   128  }
   129  
   130  // NewAuthControllerCaller creates a new read-only instance of AuthController, bound to a specific deployed contract.
   131  func NewAuthControllerCaller(address common.Address, caller bind.ContractCaller) (*AuthControllerCaller, error) {
   132  	contract, err := bindAuthController(address, caller, nil, nil)
   133  	if err != nil {
   134  		return nil, err
   135  	}
   136  	return &AuthControllerCaller{contract: contract}, nil
   137  }
   138  
   139  // NewAuthControllerTransactor creates a new write-only instance of AuthController, bound to a specific deployed contract.
   140  func NewAuthControllerTransactor(address common.Address, transactor bind.ContractTransactor) (*AuthControllerTransactor, error) {
   141  	contract, err := bindAuthController(address, nil, transactor, nil)
   142  	if err != nil {
   143  		return nil, err
   144  	}
   145  	return &AuthControllerTransactor{contract: contract}, nil
   146  }
   147  
   148  // NewAuthControllerFilterer creates a new log filterer instance of AuthController, bound to a specific deployed contract.
   149  func NewAuthControllerFilterer(address common.Address, filterer bind.ContractFilterer) (*AuthControllerFilterer, error) {
   150  	contract, err := bindAuthController(address, nil, nil, filterer)
   151  	if err != nil {
   152  		return nil, err
   153  	}
   154  	return &AuthControllerFilterer{contract: contract}, nil
   155  }
   156  
   157  // bindAuthController binds a generic wrapper to an already deployed contract.
   158  func bindAuthController(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
   159  	parsed, err := abi.JSON(strings.NewReader(AuthControllerABI))
   160  	if err != nil {
   161  		return nil, err
   162  	}
   163  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
   164  }
   165  
   166  // Call invokes the (constant) contract method with params as input values and
   167  // sets the output to result. The result type might be a single field for simple
   168  // returns, a slice of interfaces for anonymous returns and a struct for named
   169  // returns.
   170  func (_AuthController *AuthControllerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
   171  	return _AuthController.Contract.AuthControllerCaller.contract.Call(opts, result, method, params...)
   172  }
   173  
   174  // Transfer initiates a plain transaction to move funds to the contract, calling
   175  // its default method if one is available.
   176  func (_AuthController *AuthControllerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   177  	return _AuthController.Contract.AuthControllerTransactor.contract.Transfer(opts)
   178  }
   179  
   180  // Transact invokes the (paid) contract method with params as input values.
   181  func (_AuthController *AuthControllerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   182  	return _AuthController.Contract.AuthControllerTransactor.contract.Transact(opts, method, params...)
   183  }
   184  
   185  // Call invokes the (constant) contract method with params as input values and
   186  // sets the output to result. The result type might be a single field for simple
   187  // returns, a slice of interfaces for anonymous returns and a struct for named
   188  // returns.
   189  func (_AuthController *AuthControllerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
   190  	return _AuthController.Contract.contract.Call(opts, result, method, params...)
   191  }
   192  
   193  // Transfer initiates a plain transaction to move funds to the contract, calling
   194  // its default method if one is available.
   195  func (_AuthController *AuthControllerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   196  	return _AuthController.Contract.contract.Transfer(opts)
   197  }
   198  
   199  // Transact invokes the (paid) contract method with params as input values.
   200  func (_AuthController *AuthControllerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   201  	return _AuthController.Contract.contract.Transact(opts, method, params...)
   202  }
   203  
   204  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
   205  //
   206  // Solidity: function isOwner() constant returns(bool)
   207  func (_AuthController *AuthControllerCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
   208  	var (
   209  		ret0 = new(bool)
   210  	)
   211  	out := ret0
   212  	err := _AuthController.contract.Call(opts, out, "isOwner")
   213  	return *ret0, err
   214  }
   215  
   216  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
   217  //
   218  // Solidity: function isOwner() constant returns(bool)
   219  func (_AuthController *AuthControllerSession) IsOwner() (bool, error) {
   220  	return _AuthController.Contract.IsOwner(&_AuthController.CallOpts)
   221  }
   222  
   223  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
   224  //
   225  // Solidity: function isOwner() constant returns(bool)
   226  func (_AuthController *AuthControllerCallerSession) IsOwner() (bool, error) {
   227  	return _AuthController.Contract.IsOwner(&_AuthController.CallOpts)
   228  }
   229  
   230  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
   231  //
   232  // Solidity: function owner() constant returns(address)
   233  func (_AuthController *AuthControllerCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
   234  	var (
   235  		ret0 = new(common.Address)
   236  	)
   237  	out := ret0
   238  	err := _AuthController.contract.Call(opts, out, "owner")
   239  	return *ret0, err
   240  }
   241  
   242  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
   243  //
   244  // Solidity: function owner() constant returns(address)
   245  func (_AuthController *AuthControllerSession) Owner() (common.Address, error) {
   246  	return _AuthController.Contract.Owner(&_AuthController.CallOpts)
   247  }
   248  
   249  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
   250  //
   251  // Solidity: function owner() constant returns(address)
   252  func (_AuthController *AuthControllerCallerSession) Owner() (common.Address, error) {
   253  	return _AuthController.Contract.Owner(&_AuthController.CallOpts)
   254  }
   255  
   256  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
   257  //
   258  // Solidity: function renounceMinter(address target) returns()
   259  func (_AuthController *AuthControllerTransactor) RenounceMinter(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
   260  	return _AuthController.contract.Transact(opts, "renounceMinter", target)
   261  }
   262  
   263  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
   264  //
   265  // Solidity: function renounceMinter(address target) returns()
   266  func (_AuthController *AuthControllerSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
   267  	return _AuthController.Contract.RenounceMinter(&_AuthController.TransactOpts, target)
   268  }
   269  
   270  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
   271  //
   272  // Solidity: function renounceMinter(address target) returns()
   273  func (_AuthController *AuthControllerTransactorSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
   274  	return _AuthController.Contract.RenounceMinter(&_AuthController.TransactOpts, target)
   275  }
   276  
   277  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
   278  //
   279  // Solidity: function renounceOwnership(address target) returns()
   280  func (_AuthController *AuthControllerTransactor) RenounceOwnership(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
   281  	return _AuthController.contract.Transact(opts, "renounceOwnership", target)
   282  }
   283  
   284  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
   285  //
   286  // Solidity: function renounceOwnership(address target) returns()
   287  func (_AuthController *AuthControllerSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
   288  	return _AuthController.Contract.RenounceOwnership(&_AuthController.TransactOpts, target)
   289  }
   290  
   291  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
   292  //
   293  // Solidity: function renounceOwnership(address target) returns()
   294  func (_AuthController *AuthControllerTransactorSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
   295  	return _AuthController.Contract.RenounceOwnership(&_AuthController.TransactOpts, target)
   296  }
   297  
   298  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
   299  //
   300  // Solidity: function renounceOwnership() returns()
   301  func (_AuthController *AuthControllerTransactor) RenounceOwnership0(opts *bind.TransactOpts) (*types.Transaction, error) {
   302  	return _AuthController.contract.Transact(opts, "renounceOwnership0")
   303  }
   304  
   305  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
   306  //
   307  // Solidity: function renounceOwnership() returns()
   308  func (_AuthController *AuthControllerSession) RenounceOwnership0() (*types.Transaction, error) {
   309  	return _AuthController.Contract.RenounceOwnership0(&_AuthController.TransactOpts)
   310  }
   311  
   312  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
   313  //
   314  // Solidity: function renounceOwnership() returns()
   315  func (_AuthController *AuthControllerTransactorSession) RenounceOwnership0() (*types.Transaction, error) {
   316  	return _AuthController.Contract.RenounceOwnership0(&_AuthController.TransactOpts)
   317  }
   318  
   319  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
   320  //
   321  // Solidity: function renouncePauser(address target) returns()
   322  func (_AuthController *AuthControllerTransactor) RenouncePauser(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
   323  	return _AuthController.contract.Transact(opts, "renouncePauser", target)
   324  }
   325  
   326  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
   327  //
   328  // Solidity: function renouncePauser(address target) returns()
   329  func (_AuthController *AuthControllerSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
   330  	return _AuthController.Contract.RenouncePauser(&_AuthController.TransactOpts, target)
   331  }
   332  
   333  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
   334  //
   335  // Solidity: function renouncePauser(address target) returns()
   336  func (_AuthController *AuthControllerTransactorSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
   337  	return _AuthController.Contract.RenouncePauser(&_AuthController.TransactOpts, target)
   338  }
   339  
   340  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
   341  //
   342  // Solidity: function transferOwnership(address target, address newOwner) returns()
   343  func (_AuthController *AuthControllerTransactor) TransferOwnership(opts *bind.TransactOpts, target common.Address, newOwner common.Address) (*types.Transaction, error) {
   344  	return _AuthController.contract.Transact(opts, "transferOwnership", target, newOwner)
   345  }
   346  
   347  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
   348  //
   349  // Solidity: function transferOwnership(address target, address newOwner) returns()
   350  func (_AuthController *AuthControllerSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
   351  	return _AuthController.Contract.TransferOwnership(&_AuthController.TransactOpts, target, newOwner)
   352  }
   353  
   354  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
   355  //
   356  // Solidity: function transferOwnership(address target, address newOwner) returns()
   357  func (_AuthController *AuthControllerTransactorSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
   358  	return _AuthController.Contract.TransferOwnership(&_AuthController.TransactOpts, target, newOwner)
   359  }
   360  
   361  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
   362  //
   363  // Solidity: function transferOwnership(address newOwner) returns()
   364  func (_AuthController *AuthControllerTransactor) TransferOwnership0(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
   365  	return _AuthController.contract.Transact(opts, "transferOwnership0", newOwner)
   366  }
   367  
   368  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
   369  //
   370  // Solidity: function transferOwnership(address newOwner) returns()
   371  func (_AuthController *AuthControllerSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
   372  	return _AuthController.Contract.TransferOwnership0(&_AuthController.TransactOpts, newOwner)
   373  }
   374  
   375  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
   376  //
   377  // Solidity: function transferOwnership(address newOwner) returns()
   378  func (_AuthController *AuthControllerTransactorSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
   379  	return _AuthController.Contract.TransferOwnership0(&_AuthController.TransactOpts, newOwner)
   380  }
   381  
   382  // AuthControllerOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the AuthController contract.
   383  type AuthControllerOwnershipTransferredIterator struct {
   384  	Event *AuthControllerOwnershipTransferred // Event containing the contract specifics and raw log
   385  
   386  	contract *bind.BoundContract // Generic contract to use for unpacking event data
   387  	event    string              // Event name to use for unpacking event data
   388  
   389  	logs chan types.Log        // Log channel receiving the found contract events
   390  	sub  ethereum.Subscription // Subscription for errors, completion and termination
   391  	done bool                  // Whether the subscription completed delivering logs
   392  	fail error                 // Occurred error to stop iteration
   393  }
   394  
   395  // Next advances the iterator to the subsequent event, returning whether there
   396  // are any more events found. In case of a retrieval or parsing error, false is
   397  // returned and Error() can be queried for the exact failure.
   398  func (it *AuthControllerOwnershipTransferredIterator) Next() bool {
   399  	// If the iterator failed, stop iterating
   400  	if it.fail != nil {
   401  		return false
   402  	}
   403  	// If the iterator completed, deliver directly whatever's available
   404  	if it.done {
   405  		select {
   406  		case log := <-it.logs:
   407  			it.Event = new(AuthControllerOwnershipTransferred)
   408  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
   409  				it.fail = err
   410  				return false
   411  			}
   412  			it.Event.Raw = log
   413  			return true
   414  
   415  		default:
   416  			return false
   417  		}
   418  	}
   419  	// Iterator still in progress, wait for either a data or an error event
   420  	select {
   421  	case log := <-it.logs:
   422  		it.Event = new(AuthControllerOwnershipTransferred)
   423  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
   424  			it.fail = err
   425  			return false
   426  		}
   427  		it.Event.Raw = log
   428  		return true
   429  
   430  	case err := <-it.sub.Err():
   431  		it.done = true
   432  		it.fail = err
   433  		return it.Next()
   434  	}
   435  }
   436  
   437  // Error returns any retrieval or parsing error occurred during filtering.
   438  func (it *AuthControllerOwnershipTransferredIterator) Error() error {
   439  	return it.fail
   440  }
   441  
   442  // Close terminates the iteration process, releasing any pending underlying
   443  // resources.
   444  func (it *AuthControllerOwnershipTransferredIterator) Close() error {
   445  	it.sub.Unsubscribe()
   446  	return nil
   447  }
   448  
   449  // AuthControllerOwnershipTransferred represents a OwnershipTransferred event raised by the AuthController contract.
   450  type AuthControllerOwnershipTransferred struct {
   451  	PreviousOwner common.Address
   452  	NewOwner      common.Address
   453  	Raw           types.Log // Blockchain specific contextual infos
   454  }
   455  
   456  // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
   457  //
   458  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
   459  func (_AuthController *AuthControllerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*AuthControllerOwnershipTransferredIterator, error) {
   460  
   461  	var previousOwnerRule []interface{}
   462  	for _, previousOwnerItem := range previousOwner {
   463  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
   464  	}
   465  	var newOwnerRule []interface{}
   466  	for _, newOwnerItem := range newOwner {
   467  		newOwnerRule = append(newOwnerRule, newOwnerItem)
   468  	}
   469  
   470  	logs, sub, err := _AuthController.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
   471  	if err != nil {
   472  		return nil, err
   473  	}
   474  	return &AuthControllerOwnershipTransferredIterator{contract: _AuthController.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
   475  }
   476  
   477  // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
   478  //
   479  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
   480  func (_AuthController *AuthControllerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *AuthControllerOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {
   481  
   482  	var previousOwnerRule []interface{}
   483  	for _, previousOwnerItem := range previousOwner {
   484  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
   485  	}
   486  	var newOwnerRule []interface{}
   487  	for _, newOwnerItem := range newOwner {
   488  		newOwnerRule = append(newOwnerRule, newOwnerItem)
   489  	}
   490  
   491  	logs, sub, err := _AuthController.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
   492  	if err != nil {
   493  		return nil, err
   494  	}
   495  	return event.NewSubscription(func(quit <-chan struct{}) error {
   496  		defer sub.Unsubscribe()
   497  		for {
   498  			select {
   499  			case log := <-logs:
   500  				// New log arrived, parse the event and forward to the user
   501  				event := new(AuthControllerOwnershipTransferred)
   502  				if err := _AuthController.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
   503  					return err
   504  				}
   505  				event.Raw = log
   506  
   507  				select {
   508  				case sink <- event:
   509  				case err := <-sub.Err():
   510  					return err
   511  				case <-quit:
   512  					return nil
   513  				}
   514  			case err := <-sub.Err():
   515  				return err
   516  			case <-quit:
   517  				return nil
   518  			}
   519  		}
   520  	}), nil
   521  }
   522  
   523  // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
   524  //
   525  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
   526  func (_AuthController *AuthControllerFilterer) ParseOwnershipTransferred(log types.Log) (*AuthControllerOwnershipTransferred, error) {
   527  	event := new(AuthControllerOwnershipTransferred)
   528  	if err := _AuthController.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
   529  		return nil, err
   530  	}
   531  	return event, nil
   532  }
   533  
   534  // ContextABI is the input ABI used to generate the binding from.
   535  const ContextABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]"
   536  
   537  // Context is an auto generated Go binding around an Ethereum contract.
   538  type Context struct {
   539  	ContextCaller     // Read-only binding to the contract
   540  	ContextTransactor // Write-only binding to the contract
   541  	ContextFilterer   // Log filterer for contract events
   542  }
   543  
   544  // ContextCaller is an auto generated read-only Go binding around an Ethereum contract.
   545  type ContextCaller struct {
   546  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   547  }
   548  
   549  // ContextTransactor is an auto generated write-only Go binding around an Ethereum contract.
   550  type ContextTransactor struct {
   551  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   552  }
   553  
   554  // ContextFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
   555  type ContextFilterer struct {
   556  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   557  }
   558  
   559  // ContextSession is an auto generated Go binding around an Ethereum contract,
   560  // with pre-set call and transact options.
   561  type ContextSession struct {
   562  	Contract     *Context          // Generic contract binding to set the session for
   563  	CallOpts     bind.CallOpts     // Call options to use throughout this session
   564  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
   565  }
   566  
   567  // ContextCallerSession is an auto generated read-only Go binding around an Ethereum contract,
   568  // with pre-set call options.
   569  type ContextCallerSession struct {
   570  	Contract *ContextCaller // Generic contract caller binding to set the session for
   571  	CallOpts bind.CallOpts  // Call options to use throughout this session
   572  }
   573  
   574  // ContextTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
   575  // with pre-set transact options.
   576  type ContextTransactorSession struct {
   577  	Contract     *ContextTransactor // Generic contract transactor binding to set the session for
   578  	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
   579  }
   580  
   581  // ContextRaw is an auto generated low-level Go binding around an Ethereum contract.
   582  type ContextRaw struct {
   583  	Contract *Context // Generic contract binding to access the raw methods on
   584  }
   585  
   586  // ContextCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
   587  type ContextCallerRaw struct {
   588  	Contract *ContextCaller // Generic read-only contract binding to access the raw methods on
   589  }
   590  
   591  // ContextTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
   592  type ContextTransactorRaw struct {
   593  	Contract *ContextTransactor // Generic write-only contract binding to access the raw methods on
   594  }
   595  
   596  // NewContext creates a new instance of Context, bound to a specific deployed contract.
   597  func NewContext(address common.Address, backend bind.ContractBackend) (*Context, error) {
   598  	contract, err := bindContext(address, backend, backend, backend)
   599  	if err != nil {
   600  		return nil, err
   601  	}
   602  	return &Context{ContextCaller: ContextCaller{contract: contract}, ContextTransactor: ContextTransactor{contract: contract}, ContextFilterer: ContextFilterer{contract: contract}}, nil
   603  }
   604  
   605  // NewContextCaller creates a new read-only instance of Context, bound to a specific deployed contract.
   606  func NewContextCaller(address common.Address, caller bind.ContractCaller) (*ContextCaller, error) {
   607  	contract, err := bindContext(address, caller, nil, nil)
   608  	if err != nil {
   609  		return nil, err
   610  	}
   611  	return &ContextCaller{contract: contract}, nil
   612  }
   613  
   614  // NewContextTransactor creates a new write-only instance of Context, bound to a specific deployed contract.
   615  func NewContextTransactor(address common.Address, transactor bind.ContractTransactor) (*ContextTransactor, error) {
   616  	contract, err := bindContext(address, nil, transactor, nil)
   617  	if err != nil {
   618  		return nil, err
   619  	}
   620  	return &ContextTransactor{contract: contract}, nil
   621  }
   622  
   623  // NewContextFilterer creates a new log filterer instance of Context, bound to a specific deployed contract.
   624  func NewContextFilterer(address common.Address, filterer bind.ContractFilterer) (*ContextFilterer, error) {
   625  	contract, err := bindContext(address, nil, nil, filterer)
   626  	if err != nil {
   627  		return nil, err
   628  	}
   629  	return &ContextFilterer{contract: contract}, nil
   630  }
   631  
   632  // bindContext binds a generic wrapper to an already deployed contract.
   633  func bindContext(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
   634  	parsed, err := abi.JSON(strings.NewReader(ContextABI))
   635  	if err != nil {
   636  		return nil, err
   637  	}
   638  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
   639  }
   640  
   641  // Call invokes the (constant) contract method with params as input values and
   642  // sets the output to result. The result type might be a single field for simple
   643  // returns, a slice of interfaces for anonymous returns and a struct for named
   644  // returns.
   645  func (_Context *ContextRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
   646  	return _Context.Contract.ContextCaller.contract.Call(opts, result, method, params...)
   647  }
   648  
   649  // Transfer initiates a plain transaction to move funds to the contract, calling
   650  // its default method if one is available.
   651  func (_Context *ContextRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   652  	return _Context.Contract.ContextTransactor.contract.Transfer(opts)
   653  }
   654  
   655  // Transact invokes the (paid) contract method with params as input values.
   656  func (_Context *ContextRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   657  	return _Context.Contract.ContextTransactor.contract.Transact(opts, method, params...)
   658  }
   659  
   660  // Call invokes the (constant) contract method with params as input values and
   661  // sets the output to result. The result type might be a single field for simple
   662  // returns, a slice of interfaces for anonymous returns and a struct for named
   663  // returns.
   664  func (_Context *ContextCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
   665  	return _Context.Contract.contract.Call(opts, result, method, params...)
   666  }
   667  
   668  // Transfer initiates a plain transaction to move funds to the contract, calling
   669  // its default method if one is available.
   670  func (_Context *ContextTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   671  	return _Context.Contract.contract.Transfer(opts)
   672  }
   673  
   674  // Transact invokes the (paid) contract method with params as input values.
   675  func (_Context *ContextTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   676  	return _Context.Contract.contract.Transact(opts, method, params...)
   677  }
   678  
   679  // ERC165CheckerABI is the input ABI used to generate the binding from.
   680  const ERC165CheckerABI = "[]"
   681  
   682  // ERC165CheckerBin is the compiled bytecode used for deploying new contracts.
   683  var ERC165CheckerBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a72315820ea851d268567a3ed8f55b193eb1a6f3028b7565ea2152c791833f991fbaa44e864736f6c634300050c0032"
   684  
   685  // DeployERC165Checker deploys a new Ethereum contract, binding an instance of ERC165Checker to it.
   686  func DeployERC165Checker(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC165Checker, error) {
   687  	parsed, err := abi.JSON(strings.NewReader(ERC165CheckerABI))
   688  	if err != nil {
   689  		return common.Address{}, nil, nil, err
   690  	}
   691  
   692  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC165CheckerBin), backend)
   693  	if err != nil {
   694  		return common.Address{}, nil, nil, err
   695  	}
   696  	return address, tx, &ERC165Checker{ERC165CheckerCaller: ERC165CheckerCaller{contract: contract}, ERC165CheckerTransactor: ERC165CheckerTransactor{contract: contract}, ERC165CheckerFilterer: ERC165CheckerFilterer{contract: contract}}, nil
   697  }
   698  
   699  // ERC165Checker is an auto generated Go binding around an Ethereum contract.
   700  type ERC165Checker struct {
   701  	ERC165CheckerCaller     // Read-only binding to the contract
   702  	ERC165CheckerTransactor // Write-only binding to the contract
   703  	ERC165CheckerFilterer   // Log filterer for contract events
   704  }
   705  
   706  // ERC165CheckerCaller is an auto generated read-only Go binding around an Ethereum contract.
   707  type ERC165CheckerCaller struct {
   708  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   709  }
   710  
   711  // ERC165CheckerTransactor is an auto generated write-only Go binding around an Ethereum contract.
   712  type ERC165CheckerTransactor struct {
   713  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   714  }
   715  
   716  // ERC165CheckerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
   717  type ERC165CheckerFilterer struct {
   718  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   719  }
   720  
   721  // ERC165CheckerSession is an auto generated Go binding around an Ethereum contract,
   722  // with pre-set call and transact options.
   723  type ERC165CheckerSession struct {
   724  	Contract     *ERC165Checker    // Generic contract binding to set the session for
   725  	CallOpts     bind.CallOpts     // Call options to use throughout this session
   726  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
   727  }
   728  
   729  // ERC165CheckerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
   730  // with pre-set call options.
   731  type ERC165CheckerCallerSession struct {
   732  	Contract *ERC165CheckerCaller // Generic contract caller binding to set the session for
   733  	CallOpts bind.CallOpts        // Call options to use throughout this session
   734  }
   735  
   736  // ERC165CheckerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
   737  // with pre-set transact options.
   738  type ERC165CheckerTransactorSession struct {
   739  	Contract     *ERC165CheckerTransactor // Generic contract transactor binding to set the session for
   740  	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
   741  }
   742  
   743  // ERC165CheckerRaw is an auto generated low-level Go binding around an Ethereum contract.
   744  type ERC165CheckerRaw struct {
   745  	Contract *ERC165Checker // Generic contract binding to access the raw methods on
   746  }
   747  
   748  // ERC165CheckerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
   749  type ERC165CheckerCallerRaw struct {
   750  	Contract *ERC165CheckerCaller // Generic read-only contract binding to access the raw methods on
   751  }
   752  
   753  // ERC165CheckerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
   754  type ERC165CheckerTransactorRaw struct {
   755  	Contract *ERC165CheckerTransactor // Generic write-only contract binding to access the raw methods on
   756  }
   757  
   758  // NewERC165Checker creates a new instance of ERC165Checker, bound to a specific deployed contract.
   759  func NewERC165Checker(address common.Address, backend bind.ContractBackend) (*ERC165Checker, error) {
   760  	contract, err := bindERC165Checker(address, backend, backend, backend)
   761  	if err != nil {
   762  		return nil, err
   763  	}
   764  	return &ERC165Checker{ERC165CheckerCaller: ERC165CheckerCaller{contract: contract}, ERC165CheckerTransactor: ERC165CheckerTransactor{contract: contract}, ERC165CheckerFilterer: ERC165CheckerFilterer{contract: contract}}, nil
   765  }
   766  
   767  // NewERC165CheckerCaller creates a new read-only instance of ERC165Checker, bound to a specific deployed contract.
   768  func NewERC165CheckerCaller(address common.Address, caller bind.ContractCaller) (*ERC165CheckerCaller, error) {
   769  	contract, err := bindERC165Checker(address, caller, nil, nil)
   770  	if err != nil {
   771  		return nil, err
   772  	}
   773  	return &ERC165CheckerCaller{contract: contract}, nil
   774  }
   775  
   776  // NewERC165CheckerTransactor creates a new write-only instance of ERC165Checker, bound to a specific deployed contract.
   777  func NewERC165CheckerTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC165CheckerTransactor, error) {
   778  	contract, err := bindERC165Checker(address, nil, transactor, nil)
   779  	if err != nil {
   780  		return nil, err
   781  	}
   782  	return &ERC165CheckerTransactor{contract: contract}, nil
   783  }
   784  
   785  // NewERC165CheckerFilterer creates a new log filterer instance of ERC165Checker, bound to a specific deployed contract.
   786  func NewERC165CheckerFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC165CheckerFilterer, error) {
   787  	contract, err := bindERC165Checker(address, nil, nil, filterer)
   788  	if err != nil {
   789  		return nil, err
   790  	}
   791  	return &ERC165CheckerFilterer{contract: contract}, nil
   792  }
   793  
   794  // bindERC165Checker binds a generic wrapper to an already deployed contract.
   795  func bindERC165Checker(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
   796  	parsed, err := abi.JSON(strings.NewReader(ERC165CheckerABI))
   797  	if err != nil {
   798  		return nil, err
   799  	}
   800  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
   801  }
   802  
   803  // Call invokes the (constant) contract method with params as input values and
   804  // sets the output to result. The result type might be a single field for simple
   805  // returns, a slice of interfaces for anonymous returns and a struct for named
   806  // returns.
   807  func (_ERC165Checker *ERC165CheckerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
   808  	return _ERC165Checker.Contract.ERC165CheckerCaller.contract.Call(opts, result, method, params...)
   809  }
   810  
   811  // Transfer initiates a plain transaction to move funds to the contract, calling
   812  // its default method if one is available.
   813  func (_ERC165Checker *ERC165CheckerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   814  	return _ERC165Checker.Contract.ERC165CheckerTransactor.contract.Transfer(opts)
   815  }
   816  
   817  // Transact invokes the (paid) contract method with params as input values.
   818  func (_ERC165Checker *ERC165CheckerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   819  	return _ERC165Checker.Contract.ERC165CheckerTransactor.contract.Transact(opts, method, params...)
   820  }
   821  
   822  // Call invokes the (constant) contract method with params as input values and
   823  // sets the output to result. The result type might be a single field for simple
   824  // returns, a slice of interfaces for anonymous returns and a struct for named
   825  // returns.
   826  func (_ERC165Checker *ERC165CheckerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
   827  	return _ERC165Checker.Contract.contract.Call(opts, result, method, params...)
   828  }
   829  
   830  // Transfer initiates a plain transaction to move funds to the contract, calling
   831  // its default method if one is available.
   832  func (_ERC165Checker *ERC165CheckerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   833  	return _ERC165Checker.Contract.contract.Transfer(opts)
   834  }
   835  
   836  // Transact invokes the (paid) contract method with params as input values.
   837  func (_ERC165Checker *ERC165CheckerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   838  	return _ERC165Checker.Contract.contract.Transact(opts, method, params...)
   839  }
   840  
   841  // ERC20ABI is the input ABI used to generate the binding from.
   842  const ERC20ABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
   843  
   844  // ERC20FuncSigs maps the 4-byte function signature to its string representation.
   845  var ERC20FuncSigs = map[string]string{
   846  	"dd62ed3e": "allowance(address,address)",
   847  	"095ea7b3": "approve(address,uint256)",
   848  	"70a08231": "balanceOf(address)",
   849  	"a457c2d7": "decreaseAllowance(address,uint256)",
   850  	"39509351": "increaseAllowance(address,uint256)",
   851  	"18160ddd": "totalSupply()",
   852  	"a9059cbb": "transfer(address,uint256)",
   853  	"23b872dd": "transferFrom(address,address,uint256)",
   854  }
   855  
   856  // ERC20Bin is the compiled bytecode used for deploying new contracts.
   857  var ERC20Bin = "0x608060405261083b806100136000396000f3fe608060405234801561001057600080fd5b50600436106100885760003560e01c806370a082311161005b57806370a0823114610149578063a457c2d71461016f578063a9059cbb1461019b578063dd62ed3e146101c757610088565b8063095ea7b31461008d57806318160ddd146100cd57806323b872dd146100e7578063395093511461011d575b600080fd5b6100b9600480360360408110156100a357600080fd5b506001600160a01b0381351690602001356101f5565b604080519115158252519081900360200190f35b6100d5610212565b60408051918252519081900360200190f35b6100b9600480360360608110156100fd57600080fd5b506001600160a01b03813581169160208101359091169060400135610218565b6100b96004803603604081101561013357600080fd5b506001600160a01b0381351690602001356102a5565b6100d56004803603602081101561015f57600080fd5b50356001600160a01b03166102f9565b6100b96004803603604081101561018557600080fd5b506001600160a01b038135169060200135610314565b6100b9600480360360408110156101b157600080fd5b506001600160a01b038135169060200135610382565b6100d5600480360360408110156101dd57600080fd5b506001600160a01b0381358116916020013516610396565b60006102096102026103c1565b84846103c5565b50600192915050565b60025490565b60006102258484846104b1565b61029b846102316103c1565b61029685604051806060016040528060288152602001610771602891396001600160a01b038a1660009081526001602052604081209061026f6103c1565b6001600160a01b03168152602081019190915260400160002054919063ffffffff61060d16565b6103c5565b5060019392505050565b60006102096102b26103c1565b8461029685600160006102c36103c1565b6001600160a01b03908116825260208083019390935260409182016000908120918c16815292529020549063ffffffff6106a416565b6001600160a01b031660009081526020819052604090205490565b60006102096103216103c1565b84610296856040518060600160405280602581526020016107e2602591396001600061034b6103c1565b6001600160a01b03908116825260208083019390935260409182016000908120918d1681529252902054919063ffffffff61060d16565b600061020961038f6103c1565b84846104b1565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b3390565b6001600160a01b03831661040a5760405162461bcd60e51b81526004018080602001828103825260248152602001806107be6024913960400191505060405180910390fd5b6001600160a01b03821661044f5760405162461bcd60e51b81526004018080602001828103825260228152602001806107296022913960400191505060405180910390fd5b6001600160a01b03808416600081815260016020908152604080832094871680845294825291829020859055815185815291517f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259281900390910190a3505050565b6001600160a01b0383166104f65760405162461bcd60e51b81526004018080602001828103825260258152602001806107996025913960400191505060405180910390fd5b6001600160a01b03821661053b5760405162461bcd60e51b81526004018080602001828103825260238152602001806107066023913960400191505060405180910390fd5b61057e8160405180606001604052806026815260200161074b602691396001600160a01b038616600090815260208190526040902054919063ffffffff61060d16565b6001600160a01b0380851660009081526020819052604080822093909355908416815220546105b3908263ffffffff6106a416565b6001600160a01b038084166000818152602081815260409182902094909455805185815290519193928716927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef92918290030190a3505050565b6000818484111561069c5760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b83811015610661578181015183820152602001610649565b50505050905090810190601f16801561068e5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b505050900390565b6000828201838110156106fe576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b939250505056fe45524332303a207472616e7366657220746f20746865207a65726f206164647265737345524332303a20617070726f766520746f20746865207a65726f206164647265737345524332303a207472616e7366657220616d6f756e7420657863656564732062616c616e636545524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e636545524332303a207472616e736665722066726f6d20746865207a65726f206164647265737345524332303a20617070726f76652066726f6d20746865207a65726f206164647265737345524332303a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726fa265627a7a7231582008ca9864b08faad547b35ef43549788be26de128b59e0167fefa4ac97cd6733964736f6c634300050c0032"
   858  
   859  // DeployERC20 deploys a new Ethereum contract, binding an instance of ERC20 to it.
   860  func DeployERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20, error) {
   861  	parsed, err := abi.JSON(strings.NewReader(ERC20ABI))
   862  	if err != nil {
   863  		return common.Address{}, nil, nil, err
   864  	}
   865  
   866  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20Bin), backend)
   867  	if err != nil {
   868  		return common.Address{}, nil, nil, err
   869  	}
   870  	return address, tx, &ERC20{ERC20Caller: ERC20Caller{contract: contract}, ERC20Transactor: ERC20Transactor{contract: contract}, ERC20Filterer: ERC20Filterer{contract: contract}}, nil
   871  }
   872  
   873  // ERC20 is an auto generated Go binding around an Ethereum contract.
   874  type ERC20 struct {
   875  	ERC20Caller     // Read-only binding to the contract
   876  	ERC20Transactor // Write-only binding to the contract
   877  	ERC20Filterer   // Log filterer for contract events
   878  }
   879  
   880  // ERC20Caller is an auto generated read-only Go binding around an Ethereum contract.
   881  type ERC20Caller struct {
   882  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   883  }
   884  
   885  // ERC20Transactor is an auto generated write-only Go binding around an Ethereum contract.
   886  type ERC20Transactor struct {
   887  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   888  }
   889  
   890  // ERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
   891  type ERC20Filterer struct {
   892  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   893  }
   894  
   895  // ERC20Session is an auto generated Go binding around an Ethereum contract,
   896  // with pre-set call and transact options.
   897  type ERC20Session struct {
   898  	Contract     *ERC20            // Generic contract binding to set the session for
   899  	CallOpts     bind.CallOpts     // Call options to use throughout this session
   900  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
   901  }
   902  
   903  // ERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract,
   904  // with pre-set call options.
   905  type ERC20CallerSession struct {
   906  	Contract *ERC20Caller  // Generic contract caller binding to set the session for
   907  	CallOpts bind.CallOpts // Call options to use throughout this session
   908  }
   909  
   910  // ERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
   911  // with pre-set transact options.
   912  type ERC20TransactorSession struct {
   913  	Contract     *ERC20Transactor  // Generic contract transactor binding to set the session for
   914  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
   915  }
   916  
   917  // ERC20Raw is an auto generated low-level Go binding around an Ethereum contract.
   918  type ERC20Raw struct {
   919  	Contract *ERC20 // Generic contract binding to access the raw methods on
   920  }
   921  
   922  // ERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
   923  type ERC20CallerRaw struct {
   924  	Contract *ERC20Caller // Generic read-only contract binding to access the raw methods on
   925  }
   926  
   927  // ERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
   928  type ERC20TransactorRaw struct {
   929  	Contract *ERC20Transactor // Generic write-only contract binding to access the raw methods on
   930  }
   931  
   932  // NewERC20 creates a new instance of ERC20, bound to a specific deployed contract.
   933  func NewERC20(address common.Address, backend bind.ContractBackend) (*ERC20, error) {
   934  	contract, err := bindERC20(address, backend, backend, backend)
   935  	if err != nil {
   936  		return nil, err
   937  	}
   938  	return &ERC20{ERC20Caller: ERC20Caller{contract: contract}, ERC20Transactor: ERC20Transactor{contract: contract}, ERC20Filterer: ERC20Filterer{contract: contract}}, nil
   939  }
   940  
   941  // NewERC20Caller creates a new read-only instance of ERC20, bound to a specific deployed contract.
   942  func NewERC20Caller(address common.Address, caller bind.ContractCaller) (*ERC20Caller, error) {
   943  	contract, err := bindERC20(address, caller, nil, nil)
   944  	if err != nil {
   945  		return nil, err
   946  	}
   947  	return &ERC20Caller{contract: contract}, nil
   948  }
   949  
   950  // NewERC20Transactor creates a new write-only instance of ERC20, bound to a specific deployed contract.
   951  func NewERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC20Transactor, error) {
   952  	contract, err := bindERC20(address, nil, transactor, nil)
   953  	if err != nil {
   954  		return nil, err
   955  	}
   956  	return &ERC20Transactor{contract: contract}, nil
   957  }
   958  
   959  // NewERC20Filterer creates a new log filterer instance of ERC20, bound to a specific deployed contract.
   960  func NewERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC20Filterer, error) {
   961  	contract, err := bindERC20(address, nil, nil, filterer)
   962  	if err != nil {
   963  		return nil, err
   964  	}
   965  	return &ERC20Filterer{contract: contract}, nil
   966  }
   967  
   968  // bindERC20 binds a generic wrapper to an already deployed contract.
   969  func bindERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
   970  	parsed, err := abi.JSON(strings.NewReader(ERC20ABI))
   971  	if err != nil {
   972  		return nil, err
   973  	}
   974  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
   975  }
   976  
   977  // Call invokes the (constant) contract method with params as input values and
   978  // sets the output to result. The result type might be a single field for simple
   979  // returns, a slice of interfaces for anonymous returns and a struct for named
   980  // returns.
   981  func (_ERC20 *ERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
   982  	return _ERC20.Contract.ERC20Caller.contract.Call(opts, result, method, params...)
   983  }
   984  
   985  // Transfer initiates a plain transaction to move funds to the contract, calling
   986  // its default method if one is available.
   987  func (_ERC20 *ERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   988  	return _ERC20.Contract.ERC20Transactor.contract.Transfer(opts)
   989  }
   990  
   991  // Transact invokes the (paid) contract method with params as input values.
   992  func (_ERC20 *ERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   993  	return _ERC20.Contract.ERC20Transactor.contract.Transact(opts, method, params...)
   994  }
   995  
   996  // Call invokes the (constant) contract method with params as input values and
   997  // sets the output to result. The result type might be a single field for simple
   998  // returns, a slice of interfaces for anonymous returns and a struct for named
   999  // returns.
  1000  func (_ERC20 *ERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  1001  	return _ERC20.Contract.contract.Call(opts, result, method, params...)
  1002  }
  1003  
  1004  // Transfer initiates a plain transaction to move funds to the contract, calling
  1005  // its default method if one is available.
  1006  func (_ERC20 *ERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  1007  	return _ERC20.Contract.contract.Transfer(opts)
  1008  }
  1009  
  1010  // Transact invokes the (paid) contract method with params as input values.
  1011  func (_ERC20 *ERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  1012  	return _ERC20.Contract.contract.Transact(opts, method, params...)
  1013  }
  1014  
  1015  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  1016  //
  1017  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  1018  func (_ERC20 *ERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
  1019  	var (
  1020  		ret0 = new(*big.Int)
  1021  	)
  1022  	out := ret0
  1023  	err := _ERC20.contract.Call(opts, out, "allowance", owner, spender)
  1024  	return *ret0, err
  1025  }
  1026  
  1027  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  1028  //
  1029  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  1030  func (_ERC20 *ERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  1031  	return _ERC20.Contract.Allowance(&_ERC20.CallOpts, owner, spender)
  1032  }
  1033  
  1034  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  1035  //
  1036  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  1037  func (_ERC20 *ERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  1038  	return _ERC20.Contract.Allowance(&_ERC20.CallOpts, owner, spender)
  1039  }
  1040  
  1041  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  1042  //
  1043  // Solidity: function balanceOf(address account) constant returns(uint256)
  1044  func (_ERC20 *ERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  1045  	var (
  1046  		ret0 = new(*big.Int)
  1047  	)
  1048  	out := ret0
  1049  	err := _ERC20.contract.Call(opts, out, "balanceOf", account)
  1050  	return *ret0, err
  1051  }
  1052  
  1053  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  1054  //
  1055  // Solidity: function balanceOf(address account) constant returns(uint256)
  1056  func (_ERC20 *ERC20Session) BalanceOf(account common.Address) (*big.Int, error) {
  1057  	return _ERC20.Contract.BalanceOf(&_ERC20.CallOpts, account)
  1058  }
  1059  
  1060  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  1061  //
  1062  // Solidity: function balanceOf(address account) constant returns(uint256)
  1063  func (_ERC20 *ERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) {
  1064  	return _ERC20.Contract.BalanceOf(&_ERC20.CallOpts, account)
  1065  }
  1066  
  1067  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  1068  //
  1069  // Solidity: function totalSupply() constant returns(uint256)
  1070  func (_ERC20 *ERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
  1071  	var (
  1072  		ret0 = new(*big.Int)
  1073  	)
  1074  	out := ret0
  1075  	err := _ERC20.contract.Call(opts, out, "totalSupply")
  1076  	return *ret0, err
  1077  }
  1078  
  1079  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  1080  //
  1081  // Solidity: function totalSupply() constant returns(uint256)
  1082  func (_ERC20 *ERC20Session) TotalSupply() (*big.Int, error) {
  1083  	return _ERC20.Contract.TotalSupply(&_ERC20.CallOpts)
  1084  }
  1085  
  1086  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  1087  //
  1088  // Solidity: function totalSupply() constant returns(uint256)
  1089  func (_ERC20 *ERC20CallerSession) TotalSupply() (*big.Int, error) {
  1090  	return _ERC20.Contract.TotalSupply(&_ERC20.CallOpts)
  1091  }
  1092  
  1093  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  1094  //
  1095  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  1096  func (_ERC20 *ERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
  1097  	return _ERC20.contract.Transact(opts, "approve", spender, amount)
  1098  }
  1099  
  1100  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  1101  //
  1102  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  1103  func (_ERC20 *ERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  1104  	return _ERC20.Contract.Approve(&_ERC20.TransactOpts, spender, amount)
  1105  }
  1106  
  1107  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  1108  //
  1109  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  1110  func (_ERC20 *ERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  1111  	return _ERC20.Contract.Approve(&_ERC20.TransactOpts, spender, amount)
  1112  }
  1113  
  1114  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  1115  //
  1116  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  1117  func (_ERC20 *ERC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  1118  	return _ERC20.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
  1119  }
  1120  
  1121  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  1122  //
  1123  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  1124  func (_ERC20 *ERC20Session) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  1125  	return _ERC20.Contract.DecreaseAllowance(&_ERC20.TransactOpts, spender, subtractedValue)
  1126  }
  1127  
  1128  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  1129  //
  1130  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  1131  func (_ERC20 *ERC20TransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  1132  	return _ERC20.Contract.DecreaseAllowance(&_ERC20.TransactOpts, spender, subtractedValue)
  1133  }
  1134  
  1135  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  1136  //
  1137  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  1138  func (_ERC20 *ERC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  1139  	return _ERC20.contract.Transact(opts, "increaseAllowance", spender, addedValue)
  1140  }
  1141  
  1142  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  1143  //
  1144  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  1145  func (_ERC20 *ERC20Session) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  1146  	return _ERC20.Contract.IncreaseAllowance(&_ERC20.TransactOpts, spender, addedValue)
  1147  }
  1148  
  1149  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  1150  //
  1151  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  1152  func (_ERC20 *ERC20TransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  1153  	return _ERC20.Contract.IncreaseAllowance(&_ERC20.TransactOpts, spender, addedValue)
  1154  }
  1155  
  1156  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  1157  //
  1158  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  1159  func (_ERC20 *ERC20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  1160  	return _ERC20.contract.Transact(opts, "transfer", recipient, amount)
  1161  }
  1162  
  1163  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  1164  //
  1165  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  1166  func (_ERC20 *ERC20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  1167  	return _ERC20.Contract.Transfer(&_ERC20.TransactOpts, recipient, amount)
  1168  }
  1169  
  1170  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  1171  //
  1172  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  1173  func (_ERC20 *ERC20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  1174  	return _ERC20.Contract.Transfer(&_ERC20.TransactOpts, recipient, amount)
  1175  }
  1176  
  1177  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  1178  //
  1179  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  1180  func (_ERC20 *ERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  1181  	return _ERC20.contract.Transact(opts, "transferFrom", sender, recipient, amount)
  1182  }
  1183  
  1184  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  1185  //
  1186  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  1187  func (_ERC20 *ERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  1188  	return _ERC20.Contract.TransferFrom(&_ERC20.TransactOpts, sender, recipient, amount)
  1189  }
  1190  
  1191  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  1192  //
  1193  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  1194  func (_ERC20 *ERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  1195  	return _ERC20.Contract.TransferFrom(&_ERC20.TransactOpts, sender, recipient, amount)
  1196  }
  1197  
  1198  // ERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20 contract.
  1199  type ERC20ApprovalIterator struct {
  1200  	Event *ERC20Approval // Event containing the contract specifics and raw log
  1201  
  1202  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  1203  	event    string              // Event name to use for unpacking event data
  1204  
  1205  	logs chan types.Log        // Log channel receiving the found contract events
  1206  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  1207  	done bool                  // Whether the subscription completed delivering logs
  1208  	fail error                 // Occurred error to stop iteration
  1209  }
  1210  
  1211  // Next advances the iterator to the subsequent event, returning whether there
  1212  // are any more events found. In case of a retrieval or parsing error, false is
  1213  // returned and Error() can be queried for the exact failure.
  1214  func (it *ERC20ApprovalIterator) Next() bool {
  1215  	// If the iterator failed, stop iterating
  1216  	if it.fail != nil {
  1217  		return false
  1218  	}
  1219  	// If the iterator completed, deliver directly whatever's available
  1220  	if it.done {
  1221  		select {
  1222  		case log := <-it.logs:
  1223  			it.Event = new(ERC20Approval)
  1224  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  1225  				it.fail = err
  1226  				return false
  1227  			}
  1228  			it.Event.Raw = log
  1229  			return true
  1230  
  1231  		default:
  1232  			return false
  1233  		}
  1234  	}
  1235  	// Iterator still in progress, wait for either a data or an error event
  1236  	select {
  1237  	case log := <-it.logs:
  1238  		it.Event = new(ERC20Approval)
  1239  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  1240  			it.fail = err
  1241  			return false
  1242  		}
  1243  		it.Event.Raw = log
  1244  		return true
  1245  
  1246  	case err := <-it.sub.Err():
  1247  		it.done = true
  1248  		it.fail = err
  1249  		return it.Next()
  1250  	}
  1251  }
  1252  
  1253  // Error returns any retrieval or parsing error occurred during filtering.
  1254  func (it *ERC20ApprovalIterator) Error() error {
  1255  	return it.fail
  1256  }
  1257  
  1258  // Close terminates the iteration process, releasing any pending underlying
  1259  // resources.
  1260  func (it *ERC20ApprovalIterator) Close() error {
  1261  	it.sub.Unsubscribe()
  1262  	return nil
  1263  }
  1264  
  1265  // ERC20Approval represents a Approval event raised by the ERC20 contract.
  1266  type ERC20Approval struct {
  1267  	Owner   common.Address
  1268  	Spender common.Address
  1269  	Value   *big.Int
  1270  	Raw     types.Log // Blockchain specific contextual infos
  1271  }
  1272  
  1273  // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  1274  //
  1275  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  1276  func (_ERC20 *ERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20ApprovalIterator, error) {
  1277  
  1278  	var ownerRule []interface{}
  1279  	for _, ownerItem := range owner {
  1280  		ownerRule = append(ownerRule, ownerItem)
  1281  	}
  1282  	var spenderRule []interface{}
  1283  	for _, spenderItem := range spender {
  1284  		spenderRule = append(spenderRule, spenderItem)
  1285  	}
  1286  
  1287  	logs, sub, err := _ERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
  1288  	if err != nil {
  1289  		return nil, err
  1290  	}
  1291  	return &ERC20ApprovalIterator{contract: _ERC20.contract, event: "Approval", logs: logs, sub: sub}, nil
  1292  }
  1293  
  1294  // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  1295  //
  1296  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  1297  func (_ERC20 *ERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
  1298  
  1299  	var ownerRule []interface{}
  1300  	for _, ownerItem := range owner {
  1301  		ownerRule = append(ownerRule, ownerItem)
  1302  	}
  1303  	var spenderRule []interface{}
  1304  	for _, spenderItem := range spender {
  1305  		spenderRule = append(spenderRule, spenderItem)
  1306  	}
  1307  
  1308  	logs, sub, err := _ERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
  1309  	if err != nil {
  1310  		return nil, err
  1311  	}
  1312  	return event.NewSubscription(func(quit <-chan struct{}) error {
  1313  		defer sub.Unsubscribe()
  1314  		for {
  1315  			select {
  1316  			case log := <-logs:
  1317  				// New log arrived, parse the event and forward to the user
  1318  				event := new(ERC20Approval)
  1319  				if err := _ERC20.contract.UnpackLog(event, "Approval", log); err != nil {
  1320  					return err
  1321  				}
  1322  				event.Raw = log
  1323  
  1324  				select {
  1325  				case sink <- event:
  1326  				case err := <-sub.Err():
  1327  					return err
  1328  				case <-quit:
  1329  					return nil
  1330  				}
  1331  			case err := <-sub.Err():
  1332  				return err
  1333  			case <-quit:
  1334  				return nil
  1335  			}
  1336  		}
  1337  	}), nil
  1338  }
  1339  
  1340  // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  1341  //
  1342  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  1343  func (_ERC20 *ERC20Filterer) ParseApproval(log types.Log) (*ERC20Approval, error) {
  1344  	event := new(ERC20Approval)
  1345  	if err := _ERC20.contract.UnpackLog(event, "Approval", log); err != nil {
  1346  		return nil, err
  1347  	}
  1348  	return event, nil
  1349  }
  1350  
  1351  // ERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20 contract.
  1352  type ERC20TransferIterator struct {
  1353  	Event *ERC20Transfer // Event containing the contract specifics and raw log
  1354  
  1355  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  1356  	event    string              // Event name to use for unpacking event data
  1357  
  1358  	logs chan types.Log        // Log channel receiving the found contract events
  1359  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  1360  	done bool                  // Whether the subscription completed delivering logs
  1361  	fail error                 // Occurred error to stop iteration
  1362  }
  1363  
  1364  // Next advances the iterator to the subsequent event, returning whether there
  1365  // are any more events found. In case of a retrieval or parsing error, false is
  1366  // returned and Error() can be queried for the exact failure.
  1367  func (it *ERC20TransferIterator) Next() bool {
  1368  	// If the iterator failed, stop iterating
  1369  	if it.fail != nil {
  1370  		return false
  1371  	}
  1372  	// If the iterator completed, deliver directly whatever's available
  1373  	if it.done {
  1374  		select {
  1375  		case log := <-it.logs:
  1376  			it.Event = new(ERC20Transfer)
  1377  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  1378  				it.fail = err
  1379  				return false
  1380  			}
  1381  			it.Event.Raw = log
  1382  			return true
  1383  
  1384  		default:
  1385  			return false
  1386  		}
  1387  	}
  1388  	// Iterator still in progress, wait for either a data or an error event
  1389  	select {
  1390  	case log := <-it.logs:
  1391  		it.Event = new(ERC20Transfer)
  1392  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  1393  			it.fail = err
  1394  			return false
  1395  		}
  1396  		it.Event.Raw = log
  1397  		return true
  1398  
  1399  	case err := <-it.sub.Err():
  1400  		it.done = true
  1401  		it.fail = err
  1402  		return it.Next()
  1403  	}
  1404  }
  1405  
  1406  // Error returns any retrieval or parsing error occurred during filtering.
  1407  func (it *ERC20TransferIterator) Error() error {
  1408  	return it.fail
  1409  }
  1410  
  1411  // Close terminates the iteration process, releasing any pending underlying
  1412  // resources.
  1413  func (it *ERC20TransferIterator) Close() error {
  1414  	it.sub.Unsubscribe()
  1415  	return nil
  1416  }
  1417  
  1418  // ERC20Transfer represents a Transfer event raised by the ERC20 contract.
  1419  type ERC20Transfer struct {
  1420  	From  common.Address
  1421  	To    common.Address
  1422  	Value *big.Int
  1423  	Raw   types.Log // Blockchain specific contextual infos
  1424  }
  1425  
  1426  // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  1427  //
  1428  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  1429  func (_ERC20 *ERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20TransferIterator, error) {
  1430  
  1431  	var fromRule []interface{}
  1432  	for _, fromItem := range from {
  1433  		fromRule = append(fromRule, fromItem)
  1434  	}
  1435  	var toRule []interface{}
  1436  	for _, toItem := range to {
  1437  		toRule = append(toRule, toItem)
  1438  	}
  1439  
  1440  	logs, sub, err := _ERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
  1441  	if err != nil {
  1442  		return nil, err
  1443  	}
  1444  	return &ERC20TransferIterator{contract: _ERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil
  1445  }
  1446  
  1447  // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  1448  //
  1449  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  1450  func (_ERC20 *ERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) {
  1451  
  1452  	var fromRule []interface{}
  1453  	for _, fromItem := range from {
  1454  		fromRule = append(fromRule, fromItem)
  1455  	}
  1456  	var toRule []interface{}
  1457  	for _, toItem := range to {
  1458  		toRule = append(toRule, toItem)
  1459  	}
  1460  
  1461  	logs, sub, err := _ERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
  1462  	if err != nil {
  1463  		return nil, err
  1464  	}
  1465  	return event.NewSubscription(func(quit <-chan struct{}) error {
  1466  		defer sub.Unsubscribe()
  1467  		for {
  1468  			select {
  1469  			case log := <-logs:
  1470  				// New log arrived, parse the event and forward to the user
  1471  				event := new(ERC20Transfer)
  1472  				if err := _ERC20.contract.UnpackLog(event, "Transfer", log); err != nil {
  1473  					return err
  1474  				}
  1475  				event.Raw = log
  1476  
  1477  				select {
  1478  				case sink <- event:
  1479  				case err := <-sub.Err():
  1480  					return err
  1481  				case <-quit:
  1482  					return nil
  1483  				}
  1484  			case err := <-sub.Err():
  1485  				return err
  1486  			case <-quit:
  1487  				return nil
  1488  			}
  1489  		}
  1490  	}), nil
  1491  }
  1492  
  1493  // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  1494  //
  1495  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  1496  func (_ERC20 *ERC20Filterer) ParseTransfer(log types.Log) (*ERC20Transfer, error) {
  1497  	event := new(ERC20Transfer)
  1498  	if err := _ERC20.contract.UnpackLog(event, "Transfer", log); err != nil {
  1499  		return nil, err
  1500  	}
  1501  	return event, nil
  1502  }
  1503  
  1504  // ERC20DetailedABI is the input ABI used to generate the binding from.
  1505  const ERC20DetailedABI = "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"decimals\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
  1506  
  1507  // ERC20DetailedFuncSigs maps the 4-byte function signature to its string representation.
  1508  var ERC20DetailedFuncSigs = map[string]string{
  1509  	"dd62ed3e": "allowance(address,address)",
  1510  	"095ea7b3": "approve(address,uint256)",
  1511  	"70a08231": "balanceOf(address)",
  1512  	"313ce567": "decimals()",
  1513  	"06fdde03": "name()",
  1514  	"95d89b41": "symbol()",
  1515  	"18160ddd": "totalSupply()",
  1516  	"a9059cbb": "transfer(address,uint256)",
  1517  	"23b872dd": "transferFrom(address,address,uint256)",
  1518  }
  1519  
  1520  // ERC20Detailed is an auto generated Go binding around an Ethereum contract.
  1521  type ERC20Detailed struct {
  1522  	ERC20DetailedCaller     // Read-only binding to the contract
  1523  	ERC20DetailedTransactor // Write-only binding to the contract
  1524  	ERC20DetailedFilterer   // Log filterer for contract events
  1525  }
  1526  
  1527  // ERC20DetailedCaller is an auto generated read-only Go binding around an Ethereum contract.
  1528  type ERC20DetailedCaller struct {
  1529  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  1530  }
  1531  
  1532  // ERC20DetailedTransactor is an auto generated write-only Go binding around an Ethereum contract.
  1533  type ERC20DetailedTransactor struct {
  1534  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  1535  }
  1536  
  1537  // ERC20DetailedFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  1538  type ERC20DetailedFilterer struct {
  1539  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  1540  }
  1541  
  1542  // ERC20DetailedSession is an auto generated Go binding around an Ethereum contract,
  1543  // with pre-set call and transact options.
  1544  type ERC20DetailedSession struct {
  1545  	Contract     *ERC20Detailed    // Generic contract binding to set the session for
  1546  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  1547  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  1548  }
  1549  
  1550  // ERC20DetailedCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  1551  // with pre-set call options.
  1552  type ERC20DetailedCallerSession struct {
  1553  	Contract *ERC20DetailedCaller // Generic contract caller binding to set the session for
  1554  	CallOpts bind.CallOpts        // Call options to use throughout this session
  1555  }
  1556  
  1557  // ERC20DetailedTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  1558  // with pre-set transact options.
  1559  type ERC20DetailedTransactorSession struct {
  1560  	Contract     *ERC20DetailedTransactor // Generic contract transactor binding to set the session for
  1561  	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
  1562  }
  1563  
  1564  // ERC20DetailedRaw is an auto generated low-level Go binding around an Ethereum contract.
  1565  type ERC20DetailedRaw struct {
  1566  	Contract *ERC20Detailed // Generic contract binding to access the raw methods on
  1567  }
  1568  
  1569  // ERC20DetailedCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  1570  type ERC20DetailedCallerRaw struct {
  1571  	Contract *ERC20DetailedCaller // Generic read-only contract binding to access the raw methods on
  1572  }
  1573  
  1574  // ERC20DetailedTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  1575  type ERC20DetailedTransactorRaw struct {
  1576  	Contract *ERC20DetailedTransactor // Generic write-only contract binding to access the raw methods on
  1577  }
  1578  
  1579  // NewERC20Detailed creates a new instance of ERC20Detailed, bound to a specific deployed contract.
  1580  func NewERC20Detailed(address common.Address, backend bind.ContractBackend) (*ERC20Detailed, error) {
  1581  	contract, err := bindERC20Detailed(address, backend, backend, backend)
  1582  	if err != nil {
  1583  		return nil, err
  1584  	}
  1585  	return &ERC20Detailed{ERC20DetailedCaller: ERC20DetailedCaller{contract: contract}, ERC20DetailedTransactor: ERC20DetailedTransactor{contract: contract}, ERC20DetailedFilterer: ERC20DetailedFilterer{contract: contract}}, nil
  1586  }
  1587  
  1588  // NewERC20DetailedCaller creates a new read-only instance of ERC20Detailed, bound to a specific deployed contract.
  1589  func NewERC20DetailedCaller(address common.Address, caller bind.ContractCaller) (*ERC20DetailedCaller, error) {
  1590  	contract, err := bindERC20Detailed(address, caller, nil, nil)
  1591  	if err != nil {
  1592  		return nil, err
  1593  	}
  1594  	return &ERC20DetailedCaller{contract: contract}, nil
  1595  }
  1596  
  1597  // NewERC20DetailedTransactor creates a new write-only instance of ERC20Detailed, bound to a specific deployed contract.
  1598  func NewERC20DetailedTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20DetailedTransactor, error) {
  1599  	contract, err := bindERC20Detailed(address, nil, transactor, nil)
  1600  	if err != nil {
  1601  		return nil, err
  1602  	}
  1603  	return &ERC20DetailedTransactor{contract: contract}, nil
  1604  }
  1605  
  1606  // NewERC20DetailedFilterer creates a new log filterer instance of ERC20Detailed, bound to a specific deployed contract.
  1607  func NewERC20DetailedFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20DetailedFilterer, error) {
  1608  	contract, err := bindERC20Detailed(address, nil, nil, filterer)
  1609  	if err != nil {
  1610  		return nil, err
  1611  	}
  1612  	return &ERC20DetailedFilterer{contract: contract}, nil
  1613  }
  1614  
  1615  // bindERC20Detailed binds a generic wrapper to an already deployed contract.
  1616  func bindERC20Detailed(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  1617  	parsed, err := abi.JSON(strings.NewReader(ERC20DetailedABI))
  1618  	if err != nil {
  1619  		return nil, err
  1620  	}
  1621  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  1622  }
  1623  
  1624  // Call invokes the (constant) contract method with params as input values and
  1625  // sets the output to result. The result type might be a single field for simple
  1626  // returns, a slice of interfaces for anonymous returns and a struct for named
  1627  // returns.
  1628  func (_ERC20Detailed *ERC20DetailedRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  1629  	return _ERC20Detailed.Contract.ERC20DetailedCaller.contract.Call(opts, result, method, params...)
  1630  }
  1631  
  1632  // Transfer initiates a plain transaction to move funds to the contract, calling
  1633  // its default method if one is available.
  1634  func (_ERC20Detailed *ERC20DetailedRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  1635  	return _ERC20Detailed.Contract.ERC20DetailedTransactor.contract.Transfer(opts)
  1636  }
  1637  
  1638  // Transact invokes the (paid) contract method with params as input values.
  1639  func (_ERC20Detailed *ERC20DetailedRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  1640  	return _ERC20Detailed.Contract.ERC20DetailedTransactor.contract.Transact(opts, method, params...)
  1641  }
  1642  
  1643  // Call invokes the (constant) contract method with params as input values and
  1644  // sets the output to result. The result type might be a single field for simple
  1645  // returns, a slice of interfaces for anonymous returns and a struct for named
  1646  // returns.
  1647  func (_ERC20Detailed *ERC20DetailedCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  1648  	return _ERC20Detailed.Contract.contract.Call(opts, result, method, params...)
  1649  }
  1650  
  1651  // Transfer initiates a plain transaction to move funds to the contract, calling
  1652  // its default method if one is available.
  1653  func (_ERC20Detailed *ERC20DetailedTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  1654  	return _ERC20Detailed.Contract.contract.Transfer(opts)
  1655  }
  1656  
  1657  // Transact invokes the (paid) contract method with params as input values.
  1658  func (_ERC20Detailed *ERC20DetailedTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  1659  	return _ERC20Detailed.Contract.contract.Transact(opts, method, params...)
  1660  }
  1661  
  1662  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  1663  //
  1664  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  1665  func (_ERC20Detailed *ERC20DetailedCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
  1666  	var (
  1667  		ret0 = new(*big.Int)
  1668  	)
  1669  	out := ret0
  1670  	err := _ERC20Detailed.contract.Call(opts, out, "allowance", owner, spender)
  1671  	return *ret0, err
  1672  }
  1673  
  1674  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  1675  //
  1676  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  1677  func (_ERC20Detailed *ERC20DetailedSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  1678  	return _ERC20Detailed.Contract.Allowance(&_ERC20Detailed.CallOpts, owner, spender)
  1679  }
  1680  
  1681  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  1682  //
  1683  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  1684  func (_ERC20Detailed *ERC20DetailedCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  1685  	return _ERC20Detailed.Contract.Allowance(&_ERC20Detailed.CallOpts, owner, spender)
  1686  }
  1687  
  1688  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  1689  //
  1690  // Solidity: function balanceOf(address account) constant returns(uint256)
  1691  func (_ERC20Detailed *ERC20DetailedCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  1692  	var (
  1693  		ret0 = new(*big.Int)
  1694  	)
  1695  	out := ret0
  1696  	err := _ERC20Detailed.contract.Call(opts, out, "balanceOf", account)
  1697  	return *ret0, err
  1698  }
  1699  
  1700  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  1701  //
  1702  // Solidity: function balanceOf(address account) constant returns(uint256)
  1703  func (_ERC20Detailed *ERC20DetailedSession) BalanceOf(account common.Address) (*big.Int, error) {
  1704  	return _ERC20Detailed.Contract.BalanceOf(&_ERC20Detailed.CallOpts, account)
  1705  }
  1706  
  1707  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  1708  //
  1709  // Solidity: function balanceOf(address account) constant returns(uint256)
  1710  func (_ERC20Detailed *ERC20DetailedCallerSession) BalanceOf(account common.Address) (*big.Int, error) {
  1711  	return _ERC20Detailed.Contract.BalanceOf(&_ERC20Detailed.CallOpts, account)
  1712  }
  1713  
  1714  // Decimals is a free data retrieval call binding the contract method 0x313ce567.
  1715  //
  1716  // Solidity: function decimals() constant returns(uint8)
  1717  func (_ERC20Detailed *ERC20DetailedCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
  1718  	var (
  1719  		ret0 = new(uint8)
  1720  	)
  1721  	out := ret0
  1722  	err := _ERC20Detailed.contract.Call(opts, out, "decimals")
  1723  	return *ret0, err
  1724  }
  1725  
  1726  // Decimals is a free data retrieval call binding the contract method 0x313ce567.
  1727  //
  1728  // Solidity: function decimals() constant returns(uint8)
  1729  func (_ERC20Detailed *ERC20DetailedSession) Decimals() (uint8, error) {
  1730  	return _ERC20Detailed.Contract.Decimals(&_ERC20Detailed.CallOpts)
  1731  }
  1732  
  1733  // Decimals is a free data retrieval call binding the contract method 0x313ce567.
  1734  //
  1735  // Solidity: function decimals() constant returns(uint8)
  1736  func (_ERC20Detailed *ERC20DetailedCallerSession) Decimals() (uint8, error) {
  1737  	return _ERC20Detailed.Contract.Decimals(&_ERC20Detailed.CallOpts)
  1738  }
  1739  
  1740  // Name is a free data retrieval call binding the contract method 0x06fdde03.
  1741  //
  1742  // Solidity: function name() constant returns(string)
  1743  func (_ERC20Detailed *ERC20DetailedCaller) Name(opts *bind.CallOpts) (string, error) {
  1744  	var (
  1745  		ret0 = new(string)
  1746  	)
  1747  	out := ret0
  1748  	err := _ERC20Detailed.contract.Call(opts, out, "name")
  1749  	return *ret0, err
  1750  }
  1751  
  1752  // Name is a free data retrieval call binding the contract method 0x06fdde03.
  1753  //
  1754  // Solidity: function name() constant returns(string)
  1755  func (_ERC20Detailed *ERC20DetailedSession) Name() (string, error) {
  1756  	return _ERC20Detailed.Contract.Name(&_ERC20Detailed.CallOpts)
  1757  }
  1758  
  1759  // Name is a free data retrieval call binding the contract method 0x06fdde03.
  1760  //
  1761  // Solidity: function name() constant returns(string)
  1762  func (_ERC20Detailed *ERC20DetailedCallerSession) Name() (string, error) {
  1763  	return _ERC20Detailed.Contract.Name(&_ERC20Detailed.CallOpts)
  1764  }
  1765  
  1766  // Symbol is a free data retrieval call binding the contract method 0x95d89b41.
  1767  //
  1768  // Solidity: function symbol() constant returns(string)
  1769  func (_ERC20Detailed *ERC20DetailedCaller) Symbol(opts *bind.CallOpts) (string, error) {
  1770  	var (
  1771  		ret0 = new(string)
  1772  	)
  1773  	out := ret0
  1774  	err := _ERC20Detailed.contract.Call(opts, out, "symbol")
  1775  	return *ret0, err
  1776  }
  1777  
  1778  // Symbol is a free data retrieval call binding the contract method 0x95d89b41.
  1779  //
  1780  // Solidity: function symbol() constant returns(string)
  1781  func (_ERC20Detailed *ERC20DetailedSession) Symbol() (string, error) {
  1782  	return _ERC20Detailed.Contract.Symbol(&_ERC20Detailed.CallOpts)
  1783  }
  1784  
  1785  // Symbol is a free data retrieval call binding the contract method 0x95d89b41.
  1786  //
  1787  // Solidity: function symbol() constant returns(string)
  1788  func (_ERC20Detailed *ERC20DetailedCallerSession) Symbol() (string, error) {
  1789  	return _ERC20Detailed.Contract.Symbol(&_ERC20Detailed.CallOpts)
  1790  }
  1791  
  1792  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  1793  //
  1794  // Solidity: function totalSupply() constant returns(uint256)
  1795  func (_ERC20Detailed *ERC20DetailedCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
  1796  	var (
  1797  		ret0 = new(*big.Int)
  1798  	)
  1799  	out := ret0
  1800  	err := _ERC20Detailed.contract.Call(opts, out, "totalSupply")
  1801  	return *ret0, err
  1802  }
  1803  
  1804  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  1805  //
  1806  // Solidity: function totalSupply() constant returns(uint256)
  1807  func (_ERC20Detailed *ERC20DetailedSession) TotalSupply() (*big.Int, error) {
  1808  	return _ERC20Detailed.Contract.TotalSupply(&_ERC20Detailed.CallOpts)
  1809  }
  1810  
  1811  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  1812  //
  1813  // Solidity: function totalSupply() constant returns(uint256)
  1814  func (_ERC20Detailed *ERC20DetailedCallerSession) TotalSupply() (*big.Int, error) {
  1815  	return _ERC20Detailed.Contract.TotalSupply(&_ERC20Detailed.CallOpts)
  1816  }
  1817  
  1818  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  1819  //
  1820  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  1821  func (_ERC20Detailed *ERC20DetailedTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
  1822  	return _ERC20Detailed.contract.Transact(opts, "approve", spender, amount)
  1823  }
  1824  
  1825  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  1826  //
  1827  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  1828  func (_ERC20Detailed *ERC20DetailedSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  1829  	return _ERC20Detailed.Contract.Approve(&_ERC20Detailed.TransactOpts, spender, amount)
  1830  }
  1831  
  1832  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  1833  //
  1834  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  1835  func (_ERC20Detailed *ERC20DetailedTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  1836  	return _ERC20Detailed.Contract.Approve(&_ERC20Detailed.TransactOpts, spender, amount)
  1837  }
  1838  
  1839  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  1840  //
  1841  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  1842  func (_ERC20Detailed *ERC20DetailedTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  1843  	return _ERC20Detailed.contract.Transact(opts, "transfer", recipient, amount)
  1844  }
  1845  
  1846  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  1847  //
  1848  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  1849  func (_ERC20Detailed *ERC20DetailedSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  1850  	return _ERC20Detailed.Contract.Transfer(&_ERC20Detailed.TransactOpts, recipient, amount)
  1851  }
  1852  
  1853  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  1854  //
  1855  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  1856  func (_ERC20Detailed *ERC20DetailedTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  1857  	return _ERC20Detailed.Contract.Transfer(&_ERC20Detailed.TransactOpts, recipient, amount)
  1858  }
  1859  
  1860  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  1861  //
  1862  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  1863  func (_ERC20Detailed *ERC20DetailedTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  1864  	return _ERC20Detailed.contract.Transact(opts, "transferFrom", sender, recipient, amount)
  1865  }
  1866  
  1867  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  1868  //
  1869  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  1870  func (_ERC20Detailed *ERC20DetailedSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  1871  	return _ERC20Detailed.Contract.TransferFrom(&_ERC20Detailed.TransactOpts, sender, recipient, amount)
  1872  }
  1873  
  1874  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  1875  //
  1876  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  1877  func (_ERC20Detailed *ERC20DetailedTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  1878  	return _ERC20Detailed.Contract.TransferFrom(&_ERC20Detailed.TransactOpts, sender, recipient, amount)
  1879  }
  1880  
  1881  // ERC20DetailedApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20Detailed contract.
  1882  type ERC20DetailedApprovalIterator struct {
  1883  	Event *ERC20DetailedApproval // Event containing the contract specifics and raw log
  1884  
  1885  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  1886  	event    string              // Event name to use for unpacking event data
  1887  
  1888  	logs chan types.Log        // Log channel receiving the found contract events
  1889  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  1890  	done bool                  // Whether the subscription completed delivering logs
  1891  	fail error                 // Occurred error to stop iteration
  1892  }
  1893  
  1894  // Next advances the iterator to the subsequent event, returning whether there
  1895  // are any more events found. In case of a retrieval or parsing error, false is
  1896  // returned and Error() can be queried for the exact failure.
  1897  func (it *ERC20DetailedApprovalIterator) Next() bool {
  1898  	// If the iterator failed, stop iterating
  1899  	if it.fail != nil {
  1900  		return false
  1901  	}
  1902  	// If the iterator completed, deliver directly whatever's available
  1903  	if it.done {
  1904  		select {
  1905  		case log := <-it.logs:
  1906  			it.Event = new(ERC20DetailedApproval)
  1907  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  1908  				it.fail = err
  1909  				return false
  1910  			}
  1911  			it.Event.Raw = log
  1912  			return true
  1913  
  1914  		default:
  1915  			return false
  1916  		}
  1917  	}
  1918  	// Iterator still in progress, wait for either a data or an error event
  1919  	select {
  1920  	case log := <-it.logs:
  1921  		it.Event = new(ERC20DetailedApproval)
  1922  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  1923  			it.fail = err
  1924  			return false
  1925  		}
  1926  		it.Event.Raw = log
  1927  		return true
  1928  
  1929  	case err := <-it.sub.Err():
  1930  		it.done = true
  1931  		it.fail = err
  1932  		return it.Next()
  1933  	}
  1934  }
  1935  
  1936  // Error returns any retrieval or parsing error occurred during filtering.
  1937  func (it *ERC20DetailedApprovalIterator) Error() error {
  1938  	return it.fail
  1939  }
  1940  
  1941  // Close terminates the iteration process, releasing any pending underlying
  1942  // resources.
  1943  func (it *ERC20DetailedApprovalIterator) Close() error {
  1944  	it.sub.Unsubscribe()
  1945  	return nil
  1946  }
  1947  
  1948  // ERC20DetailedApproval represents a Approval event raised by the ERC20Detailed contract.
  1949  type ERC20DetailedApproval struct {
  1950  	Owner   common.Address
  1951  	Spender common.Address
  1952  	Value   *big.Int
  1953  	Raw     types.Log // Blockchain specific contextual infos
  1954  }
  1955  
  1956  // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  1957  //
  1958  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  1959  func (_ERC20Detailed *ERC20DetailedFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20DetailedApprovalIterator, error) {
  1960  
  1961  	var ownerRule []interface{}
  1962  	for _, ownerItem := range owner {
  1963  		ownerRule = append(ownerRule, ownerItem)
  1964  	}
  1965  	var spenderRule []interface{}
  1966  	for _, spenderItem := range spender {
  1967  		spenderRule = append(spenderRule, spenderItem)
  1968  	}
  1969  
  1970  	logs, sub, err := _ERC20Detailed.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
  1971  	if err != nil {
  1972  		return nil, err
  1973  	}
  1974  	return &ERC20DetailedApprovalIterator{contract: _ERC20Detailed.contract, event: "Approval", logs: logs, sub: sub}, nil
  1975  }
  1976  
  1977  // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  1978  //
  1979  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  1980  func (_ERC20Detailed *ERC20DetailedFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20DetailedApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
  1981  
  1982  	var ownerRule []interface{}
  1983  	for _, ownerItem := range owner {
  1984  		ownerRule = append(ownerRule, ownerItem)
  1985  	}
  1986  	var spenderRule []interface{}
  1987  	for _, spenderItem := range spender {
  1988  		spenderRule = append(spenderRule, spenderItem)
  1989  	}
  1990  
  1991  	logs, sub, err := _ERC20Detailed.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
  1992  	if err != nil {
  1993  		return nil, err
  1994  	}
  1995  	return event.NewSubscription(func(quit <-chan struct{}) error {
  1996  		defer sub.Unsubscribe()
  1997  		for {
  1998  			select {
  1999  			case log := <-logs:
  2000  				// New log arrived, parse the event and forward to the user
  2001  				event := new(ERC20DetailedApproval)
  2002  				if err := _ERC20Detailed.contract.UnpackLog(event, "Approval", log); err != nil {
  2003  					return err
  2004  				}
  2005  				event.Raw = log
  2006  
  2007  				select {
  2008  				case sink <- event:
  2009  				case err := <-sub.Err():
  2010  					return err
  2011  				case <-quit:
  2012  					return nil
  2013  				}
  2014  			case err := <-sub.Err():
  2015  				return err
  2016  			case <-quit:
  2017  				return nil
  2018  			}
  2019  		}
  2020  	}), nil
  2021  }
  2022  
  2023  // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  2024  //
  2025  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  2026  func (_ERC20Detailed *ERC20DetailedFilterer) ParseApproval(log types.Log) (*ERC20DetailedApproval, error) {
  2027  	event := new(ERC20DetailedApproval)
  2028  	if err := _ERC20Detailed.contract.UnpackLog(event, "Approval", log); err != nil {
  2029  		return nil, err
  2030  	}
  2031  	return event, nil
  2032  }
  2033  
  2034  // ERC20DetailedTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20Detailed contract.
  2035  type ERC20DetailedTransferIterator struct {
  2036  	Event *ERC20DetailedTransfer // Event containing the contract specifics and raw log
  2037  
  2038  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  2039  	event    string              // Event name to use for unpacking event data
  2040  
  2041  	logs chan types.Log        // Log channel receiving the found contract events
  2042  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  2043  	done bool                  // Whether the subscription completed delivering logs
  2044  	fail error                 // Occurred error to stop iteration
  2045  }
  2046  
  2047  // Next advances the iterator to the subsequent event, returning whether there
  2048  // are any more events found. In case of a retrieval or parsing error, false is
  2049  // returned and Error() can be queried for the exact failure.
  2050  func (it *ERC20DetailedTransferIterator) Next() bool {
  2051  	// If the iterator failed, stop iterating
  2052  	if it.fail != nil {
  2053  		return false
  2054  	}
  2055  	// If the iterator completed, deliver directly whatever's available
  2056  	if it.done {
  2057  		select {
  2058  		case log := <-it.logs:
  2059  			it.Event = new(ERC20DetailedTransfer)
  2060  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2061  				it.fail = err
  2062  				return false
  2063  			}
  2064  			it.Event.Raw = log
  2065  			return true
  2066  
  2067  		default:
  2068  			return false
  2069  		}
  2070  	}
  2071  	// Iterator still in progress, wait for either a data or an error event
  2072  	select {
  2073  	case log := <-it.logs:
  2074  		it.Event = new(ERC20DetailedTransfer)
  2075  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2076  			it.fail = err
  2077  			return false
  2078  		}
  2079  		it.Event.Raw = log
  2080  		return true
  2081  
  2082  	case err := <-it.sub.Err():
  2083  		it.done = true
  2084  		it.fail = err
  2085  		return it.Next()
  2086  	}
  2087  }
  2088  
  2089  // Error returns any retrieval or parsing error occurred during filtering.
  2090  func (it *ERC20DetailedTransferIterator) Error() error {
  2091  	return it.fail
  2092  }
  2093  
  2094  // Close terminates the iteration process, releasing any pending underlying
  2095  // resources.
  2096  func (it *ERC20DetailedTransferIterator) Close() error {
  2097  	it.sub.Unsubscribe()
  2098  	return nil
  2099  }
  2100  
  2101  // ERC20DetailedTransfer represents a Transfer event raised by the ERC20Detailed contract.
  2102  type ERC20DetailedTransfer struct {
  2103  	From  common.Address
  2104  	To    common.Address
  2105  	Value *big.Int
  2106  	Raw   types.Log // Blockchain specific contextual infos
  2107  }
  2108  
  2109  // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  2110  //
  2111  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  2112  func (_ERC20Detailed *ERC20DetailedFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20DetailedTransferIterator, error) {
  2113  
  2114  	var fromRule []interface{}
  2115  	for _, fromItem := range from {
  2116  		fromRule = append(fromRule, fromItem)
  2117  	}
  2118  	var toRule []interface{}
  2119  	for _, toItem := range to {
  2120  		toRule = append(toRule, toItem)
  2121  	}
  2122  
  2123  	logs, sub, err := _ERC20Detailed.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
  2124  	if err != nil {
  2125  		return nil, err
  2126  	}
  2127  	return &ERC20DetailedTransferIterator{contract: _ERC20Detailed.contract, event: "Transfer", logs: logs, sub: sub}, nil
  2128  }
  2129  
  2130  // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  2131  //
  2132  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  2133  func (_ERC20Detailed *ERC20DetailedFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20DetailedTransfer, from []common.Address, to []common.Address) (event.Subscription, error) {
  2134  
  2135  	var fromRule []interface{}
  2136  	for _, fromItem := range from {
  2137  		fromRule = append(fromRule, fromItem)
  2138  	}
  2139  	var toRule []interface{}
  2140  	for _, toItem := range to {
  2141  		toRule = append(toRule, toItem)
  2142  	}
  2143  
  2144  	logs, sub, err := _ERC20Detailed.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
  2145  	if err != nil {
  2146  		return nil, err
  2147  	}
  2148  	return event.NewSubscription(func(quit <-chan struct{}) error {
  2149  		defer sub.Unsubscribe()
  2150  		for {
  2151  			select {
  2152  			case log := <-logs:
  2153  				// New log arrived, parse the event and forward to the user
  2154  				event := new(ERC20DetailedTransfer)
  2155  				if err := _ERC20Detailed.contract.UnpackLog(event, "Transfer", log); err != nil {
  2156  					return err
  2157  				}
  2158  				event.Raw = log
  2159  
  2160  				select {
  2161  				case sink <- event:
  2162  				case err := <-sub.Err():
  2163  					return err
  2164  				case <-quit:
  2165  					return nil
  2166  				}
  2167  			case err := <-sub.Err():
  2168  				return err
  2169  			case <-quit:
  2170  				return nil
  2171  			}
  2172  		}
  2173  	}), nil
  2174  }
  2175  
  2176  // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  2177  //
  2178  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  2179  func (_ERC20Detailed *ERC20DetailedFilterer) ParseTransfer(log types.Log) (*ERC20DetailedTransfer, error) {
  2180  	event := new(ERC20DetailedTransfer)
  2181  	if err := _ERC20Detailed.contract.UnpackLog(event, "Transfer", log); err != nil {
  2182  		return nil, err
  2183  	}
  2184  	return event, nil
  2185  }
  2186  
  2187  // ERC20MintableABI is the input ABI used to generate the binding from.
  2188  const ERC20MintableABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isMinter\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
  2189  
  2190  // ERC20MintableFuncSigs maps the 4-byte function signature to its string representation.
  2191  var ERC20MintableFuncSigs = map[string]string{
  2192  	"983b2d56": "addMinter(address)",
  2193  	"dd62ed3e": "allowance(address,address)",
  2194  	"095ea7b3": "approve(address,uint256)",
  2195  	"70a08231": "balanceOf(address)",
  2196  	"a457c2d7": "decreaseAllowance(address,uint256)",
  2197  	"39509351": "increaseAllowance(address,uint256)",
  2198  	"aa271e1a": "isMinter(address)",
  2199  	"40c10f19": "mint(address,uint256)",
  2200  	"98650275": "renounceMinter()",
  2201  	"18160ddd": "totalSupply()",
  2202  	"a9059cbb": "transfer(address,uint256)",
  2203  	"23b872dd": "transferFrom(address,address,uint256)",
  2204  }
  2205  
  2206  // ERC20MintableBin is the compiled bytecode used for deploying new contracts.
  2207  var ERC20MintableBin = "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"
  2208  
  2209  // DeployERC20Mintable deploys a new Ethereum contract, binding an instance of ERC20Mintable to it.
  2210  func DeployERC20Mintable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20Mintable, error) {
  2211  	parsed, err := abi.JSON(strings.NewReader(ERC20MintableABI))
  2212  	if err != nil {
  2213  		return common.Address{}, nil, nil, err
  2214  	}
  2215  
  2216  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20MintableBin), backend)
  2217  	if err != nil {
  2218  		return common.Address{}, nil, nil, err
  2219  	}
  2220  	return address, tx, &ERC20Mintable{ERC20MintableCaller: ERC20MintableCaller{contract: contract}, ERC20MintableTransactor: ERC20MintableTransactor{contract: contract}, ERC20MintableFilterer: ERC20MintableFilterer{contract: contract}}, nil
  2221  }
  2222  
  2223  // ERC20Mintable is an auto generated Go binding around an Ethereum contract.
  2224  type ERC20Mintable struct {
  2225  	ERC20MintableCaller     // Read-only binding to the contract
  2226  	ERC20MintableTransactor // Write-only binding to the contract
  2227  	ERC20MintableFilterer   // Log filterer for contract events
  2228  }
  2229  
  2230  // ERC20MintableCaller is an auto generated read-only Go binding around an Ethereum contract.
  2231  type ERC20MintableCaller struct {
  2232  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  2233  }
  2234  
  2235  // ERC20MintableTransactor is an auto generated write-only Go binding around an Ethereum contract.
  2236  type ERC20MintableTransactor struct {
  2237  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  2238  }
  2239  
  2240  // ERC20MintableFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  2241  type ERC20MintableFilterer struct {
  2242  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  2243  }
  2244  
  2245  // ERC20MintableSession is an auto generated Go binding around an Ethereum contract,
  2246  // with pre-set call and transact options.
  2247  type ERC20MintableSession struct {
  2248  	Contract     *ERC20Mintable    // Generic contract binding to set the session for
  2249  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  2250  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  2251  }
  2252  
  2253  // ERC20MintableCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  2254  // with pre-set call options.
  2255  type ERC20MintableCallerSession struct {
  2256  	Contract *ERC20MintableCaller // Generic contract caller binding to set the session for
  2257  	CallOpts bind.CallOpts        // Call options to use throughout this session
  2258  }
  2259  
  2260  // ERC20MintableTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  2261  // with pre-set transact options.
  2262  type ERC20MintableTransactorSession struct {
  2263  	Contract     *ERC20MintableTransactor // Generic contract transactor binding to set the session for
  2264  	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
  2265  }
  2266  
  2267  // ERC20MintableRaw is an auto generated low-level Go binding around an Ethereum contract.
  2268  type ERC20MintableRaw struct {
  2269  	Contract *ERC20Mintable // Generic contract binding to access the raw methods on
  2270  }
  2271  
  2272  // ERC20MintableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  2273  type ERC20MintableCallerRaw struct {
  2274  	Contract *ERC20MintableCaller // Generic read-only contract binding to access the raw methods on
  2275  }
  2276  
  2277  // ERC20MintableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  2278  type ERC20MintableTransactorRaw struct {
  2279  	Contract *ERC20MintableTransactor // Generic write-only contract binding to access the raw methods on
  2280  }
  2281  
  2282  // NewERC20Mintable creates a new instance of ERC20Mintable, bound to a specific deployed contract.
  2283  func NewERC20Mintable(address common.Address, backend bind.ContractBackend) (*ERC20Mintable, error) {
  2284  	contract, err := bindERC20Mintable(address, backend, backend, backend)
  2285  	if err != nil {
  2286  		return nil, err
  2287  	}
  2288  	return &ERC20Mintable{ERC20MintableCaller: ERC20MintableCaller{contract: contract}, ERC20MintableTransactor: ERC20MintableTransactor{contract: contract}, ERC20MintableFilterer: ERC20MintableFilterer{contract: contract}}, nil
  2289  }
  2290  
  2291  // NewERC20MintableCaller creates a new read-only instance of ERC20Mintable, bound to a specific deployed contract.
  2292  func NewERC20MintableCaller(address common.Address, caller bind.ContractCaller) (*ERC20MintableCaller, error) {
  2293  	contract, err := bindERC20Mintable(address, caller, nil, nil)
  2294  	if err != nil {
  2295  		return nil, err
  2296  	}
  2297  	return &ERC20MintableCaller{contract: contract}, nil
  2298  }
  2299  
  2300  // NewERC20MintableTransactor creates a new write-only instance of ERC20Mintable, bound to a specific deployed contract.
  2301  func NewERC20MintableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20MintableTransactor, error) {
  2302  	contract, err := bindERC20Mintable(address, nil, transactor, nil)
  2303  	if err != nil {
  2304  		return nil, err
  2305  	}
  2306  	return &ERC20MintableTransactor{contract: contract}, nil
  2307  }
  2308  
  2309  // NewERC20MintableFilterer creates a new log filterer instance of ERC20Mintable, bound to a specific deployed contract.
  2310  func NewERC20MintableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20MintableFilterer, error) {
  2311  	contract, err := bindERC20Mintable(address, nil, nil, filterer)
  2312  	if err != nil {
  2313  		return nil, err
  2314  	}
  2315  	return &ERC20MintableFilterer{contract: contract}, nil
  2316  }
  2317  
  2318  // bindERC20Mintable binds a generic wrapper to an already deployed contract.
  2319  func bindERC20Mintable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  2320  	parsed, err := abi.JSON(strings.NewReader(ERC20MintableABI))
  2321  	if err != nil {
  2322  		return nil, err
  2323  	}
  2324  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  2325  }
  2326  
  2327  // Call invokes the (constant) contract method with params as input values and
  2328  // sets the output to result. The result type might be a single field for simple
  2329  // returns, a slice of interfaces for anonymous returns and a struct for named
  2330  // returns.
  2331  func (_ERC20Mintable *ERC20MintableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  2332  	return _ERC20Mintable.Contract.ERC20MintableCaller.contract.Call(opts, result, method, params...)
  2333  }
  2334  
  2335  // Transfer initiates a plain transaction to move funds to the contract, calling
  2336  // its default method if one is available.
  2337  func (_ERC20Mintable *ERC20MintableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  2338  	return _ERC20Mintable.Contract.ERC20MintableTransactor.contract.Transfer(opts)
  2339  }
  2340  
  2341  // Transact invokes the (paid) contract method with params as input values.
  2342  func (_ERC20Mintable *ERC20MintableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  2343  	return _ERC20Mintable.Contract.ERC20MintableTransactor.contract.Transact(opts, method, params...)
  2344  }
  2345  
  2346  // Call invokes the (constant) contract method with params as input values and
  2347  // sets the output to result. The result type might be a single field for simple
  2348  // returns, a slice of interfaces for anonymous returns and a struct for named
  2349  // returns.
  2350  func (_ERC20Mintable *ERC20MintableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  2351  	return _ERC20Mintable.Contract.contract.Call(opts, result, method, params...)
  2352  }
  2353  
  2354  // Transfer initiates a plain transaction to move funds to the contract, calling
  2355  // its default method if one is available.
  2356  func (_ERC20Mintable *ERC20MintableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  2357  	return _ERC20Mintable.Contract.contract.Transfer(opts)
  2358  }
  2359  
  2360  // Transact invokes the (paid) contract method with params as input values.
  2361  func (_ERC20Mintable *ERC20MintableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  2362  	return _ERC20Mintable.Contract.contract.Transact(opts, method, params...)
  2363  }
  2364  
  2365  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  2366  //
  2367  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  2368  func (_ERC20Mintable *ERC20MintableCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
  2369  	var (
  2370  		ret0 = new(*big.Int)
  2371  	)
  2372  	out := ret0
  2373  	err := _ERC20Mintable.contract.Call(opts, out, "allowance", owner, spender)
  2374  	return *ret0, err
  2375  }
  2376  
  2377  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  2378  //
  2379  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  2380  func (_ERC20Mintable *ERC20MintableSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  2381  	return _ERC20Mintable.Contract.Allowance(&_ERC20Mintable.CallOpts, owner, spender)
  2382  }
  2383  
  2384  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  2385  //
  2386  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  2387  func (_ERC20Mintable *ERC20MintableCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  2388  	return _ERC20Mintable.Contract.Allowance(&_ERC20Mintable.CallOpts, owner, spender)
  2389  }
  2390  
  2391  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  2392  //
  2393  // Solidity: function balanceOf(address account) constant returns(uint256)
  2394  func (_ERC20Mintable *ERC20MintableCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  2395  	var (
  2396  		ret0 = new(*big.Int)
  2397  	)
  2398  	out := ret0
  2399  	err := _ERC20Mintable.contract.Call(opts, out, "balanceOf", account)
  2400  	return *ret0, err
  2401  }
  2402  
  2403  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  2404  //
  2405  // Solidity: function balanceOf(address account) constant returns(uint256)
  2406  func (_ERC20Mintable *ERC20MintableSession) BalanceOf(account common.Address) (*big.Int, error) {
  2407  	return _ERC20Mintable.Contract.BalanceOf(&_ERC20Mintable.CallOpts, account)
  2408  }
  2409  
  2410  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  2411  //
  2412  // Solidity: function balanceOf(address account) constant returns(uint256)
  2413  func (_ERC20Mintable *ERC20MintableCallerSession) BalanceOf(account common.Address) (*big.Int, error) {
  2414  	return _ERC20Mintable.Contract.BalanceOf(&_ERC20Mintable.CallOpts, account)
  2415  }
  2416  
  2417  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
  2418  //
  2419  // Solidity: function isMinter(address account) constant returns(bool)
  2420  func (_ERC20Mintable *ERC20MintableCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) {
  2421  	var (
  2422  		ret0 = new(bool)
  2423  	)
  2424  	out := ret0
  2425  	err := _ERC20Mintable.contract.Call(opts, out, "isMinter", account)
  2426  	return *ret0, err
  2427  }
  2428  
  2429  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
  2430  //
  2431  // Solidity: function isMinter(address account) constant returns(bool)
  2432  func (_ERC20Mintable *ERC20MintableSession) IsMinter(account common.Address) (bool, error) {
  2433  	return _ERC20Mintable.Contract.IsMinter(&_ERC20Mintable.CallOpts, account)
  2434  }
  2435  
  2436  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
  2437  //
  2438  // Solidity: function isMinter(address account) constant returns(bool)
  2439  func (_ERC20Mintable *ERC20MintableCallerSession) IsMinter(account common.Address) (bool, error) {
  2440  	return _ERC20Mintable.Contract.IsMinter(&_ERC20Mintable.CallOpts, account)
  2441  }
  2442  
  2443  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  2444  //
  2445  // Solidity: function totalSupply() constant returns(uint256)
  2446  func (_ERC20Mintable *ERC20MintableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
  2447  	var (
  2448  		ret0 = new(*big.Int)
  2449  	)
  2450  	out := ret0
  2451  	err := _ERC20Mintable.contract.Call(opts, out, "totalSupply")
  2452  	return *ret0, err
  2453  }
  2454  
  2455  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  2456  //
  2457  // Solidity: function totalSupply() constant returns(uint256)
  2458  func (_ERC20Mintable *ERC20MintableSession) TotalSupply() (*big.Int, error) {
  2459  	return _ERC20Mintable.Contract.TotalSupply(&_ERC20Mintable.CallOpts)
  2460  }
  2461  
  2462  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  2463  //
  2464  // Solidity: function totalSupply() constant returns(uint256)
  2465  func (_ERC20Mintable *ERC20MintableCallerSession) TotalSupply() (*big.Int, error) {
  2466  	return _ERC20Mintable.Contract.TotalSupply(&_ERC20Mintable.CallOpts)
  2467  }
  2468  
  2469  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
  2470  //
  2471  // Solidity: function addMinter(address account) returns()
  2472  func (_ERC20Mintable *ERC20MintableTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
  2473  	return _ERC20Mintable.contract.Transact(opts, "addMinter", account)
  2474  }
  2475  
  2476  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
  2477  //
  2478  // Solidity: function addMinter(address account) returns()
  2479  func (_ERC20Mintable *ERC20MintableSession) AddMinter(account common.Address) (*types.Transaction, error) {
  2480  	return _ERC20Mintable.Contract.AddMinter(&_ERC20Mintable.TransactOpts, account)
  2481  }
  2482  
  2483  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
  2484  //
  2485  // Solidity: function addMinter(address account) returns()
  2486  func (_ERC20Mintable *ERC20MintableTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) {
  2487  	return _ERC20Mintable.Contract.AddMinter(&_ERC20Mintable.TransactOpts, account)
  2488  }
  2489  
  2490  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  2491  //
  2492  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  2493  func (_ERC20Mintable *ERC20MintableTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
  2494  	return _ERC20Mintable.contract.Transact(opts, "approve", spender, amount)
  2495  }
  2496  
  2497  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  2498  //
  2499  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  2500  func (_ERC20Mintable *ERC20MintableSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  2501  	return _ERC20Mintable.Contract.Approve(&_ERC20Mintable.TransactOpts, spender, amount)
  2502  }
  2503  
  2504  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  2505  //
  2506  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  2507  func (_ERC20Mintable *ERC20MintableTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  2508  	return _ERC20Mintable.Contract.Approve(&_ERC20Mintable.TransactOpts, spender, amount)
  2509  }
  2510  
  2511  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  2512  //
  2513  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  2514  func (_ERC20Mintable *ERC20MintableTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  2515  	return _ERC20Mintable.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
  2516  }
  2517  
  2518  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  2519  //
  2520  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  2521  func (_ERC20Mintable *ERC20MintableSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  2522  	return _ERC20Mintable.Contract.DecreaseAllowance(&_ERC20Mintable.TransactOpts, spender, subtractedValue)
  2523  }
  2524  
  2525  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  2526  //
  2527  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  2528  func (_ERC20Mintable *ERC20MintableTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  2529  	return _ERC20Mintable.Contract.DecreaseAllowance(&_ERC20Mintable.TransactOpts, spender, subtractedValue)
  2530  }
  2531  
  2532  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  2533  //
  2534  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  2535  func (_ERC20Mintable *ERC20MintableTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  2536  	return _ERC20Mintable.contract.Transact(opts, "increaseAllowance", spender, addedValue)
  2537  }
  2538  
  2539  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  2540  //
  2541  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  2542  func (_ERC20Mintable *ERC20MintableSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  2543  	return _ERC20Mintable.Contract.IncreaseAllowance(&_ERC20Mintable.TransactOpts, spender, addedValue)
  2544  }
  2545  
  2546  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  2547  //
  2548  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  2549  func (_ERC20Mintable *ERC20MintableTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  2550  	return _ERC20Mintable.Contract.IncreaseAllowance(&_ERC20Mintable.TransactOpts, spender, addedValue)
  2551  }
  2552  
  2553  // Mint is a paid mutator transaction binding the contract method 0x40c10f19.
  2554  //
  2555  // Solidity: function mint(address account, uint256 amount) returns(bool)
  2556  func (_ERC20Mintable *ERC20MintableTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) {
  2557  	return _ERC20Mintable.contract.Transact(opts, "mint", account, amount)
  2558  }
  2559  
  2560  // Mint is a paid mutator transaction binding the contract method 0x40c10f19.
  2561  //
  2562  // Solidity: function mint(address account, uint256 amount) returns(bool)
  2563  func (_ERC20Mintable *ERC20MintableSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
  2564  	return _ERC20Mintable.Contract.Mint(&_ERC20Mintable.TransactOpts, account, amount)
  2565  }
  2566  
  2567  // Mint is a paid mutator transaction binding the contract method 0x40c10f19.
  2568  //
  2569  // Solidity: function mint(address account, uint256 amount) returns(bool)
  2570  func (_ERC20Mintable *ERC20MintableTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
  2571  	return _ERC20Mintable.Contract.Mint(&_ERC20Mintable.TransactOpts, account, amount)
  2572  }
  2573  
  2574  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  2575  //
  2576  // Solidity: function renounceMinter() returns()
  2577  func (_ERC20Mintable *ERC20MintableTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) {
  2578  	return _ERC20Mintable.contract.Transact(opts, "renounceMinter")
  2579  }
  2580  
  2581  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  2582  //
  2583  // Solidity: function renounceMinter() returns()
  2584  func (_ERC20Mintable *ERC20MintableSession) RenounceMinter() (*types.Transaction, error) {
  2585  	return _ERC20Mintable.Contract.RenounceMinter(&_ERC20Mintable.TransactOpts)
  2586  }
  2587  
  2588  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  2589  //
  2590  // Solidity: function renounceMinter() returns()
  2591  func (_ERC20Mintable *ERC20MintableTransactorSession) RenounceMinter() (*types.Transaction, error) {
  2592  	return _ERC20Mintable.Contract.RenounceMinter(&_ERC20Mintable.TransactOpts)
  2593  }
  2594  
  2595  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  2596  //
  2597  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  2598  func (_ERC20Mintable *ERC20MintableTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  2599  	return _ERC20Mintable.contract.Transact(opts, "transfer", recipient, amount)
  2600  }
  2601  
  2602  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  2603  //
  2604  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  2605  func (_ERC20Mintable *ERC20MintableSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  2606  	return _ERC20Mintable.Contract.Transfer(&_ERC20Mintable.TransactOpts, recipient, amount)
  2607  }
  2608  
  2609  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  2610  //
  2611  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  2612  func (_ERC20Mintable *ERC20MintableTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  2613  	return _ERC20Mintable.Contract.Transfer(&_ERC20Mintable.TransactOpts, recipient, amount)
  2614  }
  2615  
  2616  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  2617  //
  2618  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  2619  func (_ERC20Mintable *ERC20MintableTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  2620  	return _ERC20Mintable.contract.Transact(opts, "transferFrom", sender, recipient, amount)
  2621  }
  2622  
  2623  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  2624  //
  2625  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  2626  func (_ERC20Mintable *ERC20MintableSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  2627  	return _ERC20Mintable.Contract.TransferFrom(&_ERC20Mintable.TransactOpts, sender, recipient, amount)
  2628  }
  2629  
  2630  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  2631  //
  2632  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  2633  func (_ERC20Mintable *ERC20MintableTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  2634  	return _ERC20Mintable.Contract.TransferFrom(&_ERC20Mintable.TransactOpts, sender, recipient, amount)
  2635  }
  2636  
  2637  // ERC20MintableApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20Mintable contract.
  2638  type ERC20MintableApprovalIterator struct {
  2639  	Event *ERC20MintableApproval // Event containing the contract specifics and raw log
  2640  
  2641  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  2642  	event    string              // Event name to use for unpacking event data
  2643  
  2644  	logs chan types.Log        // Log channel receiving the found contract events
  2645  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  2646  	done bool                  // Whether the subscription completed delivering logs
  2647  	fail error                 // Occurred error to stop iteration
  2648  }
  2649  
  2650  // Next advances the iterator to the subsequent event, returning whether there
  2651  // are any more events found. In case of a retrieval or parsing error, false is
  2652  // returned and Error() can be queried for the exact failure.
  2653  func (it *ERC20MintableApprovalIterator) Next() bool {
  2654  	// If the iterator failed, stop iterating
  2655  	if it.fail != nil {
  2656  		return false
  2657  	}
  2658  	// If the iterator completed, deliver directly whatever's available
  2659  	if it.done {
  2660  		select {
  2661  		case log := <-it.logs:
  2662  			it.Event = new(ERC20MintableApproval)
  2663  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2664  				it.fail = err
  2665  				return false
  2666  			}
  2667  			it.Event.Raw = log
  2668  			return true
  2669  
  2670  		default:
  2671  			return false
  2672  		}
  2673  	}
  2674  	// Iterator still in progress, wait for either a data or an error event
  2675  	select {
  2676  	case log := <-it.logs:
  2677  		it.Event = new(ERC20MintableApproval)
  2678  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2679  			it.fail = err
  2680  			return false
  2681  		}
  2682  		it.Event.Raw = log
  2683  		return true
  2684  
  2685  	case err := <-it.sub.Err():
  2686  		it.done = true
  2687  		it.fail = err
  2688  		return it.Next()
  2689  	}
  2690  }
  2691  
  2692  // Error returns any retrieval or parsing error occurred during filtering.
  2693  func (it *ERC20MintableApprovalIterator) Error() error {
  2694  	return it.fail
  2695  }
  2696  
  2697  // Close terminates the iteration process, releasing any pending underlying
  2698  // resources.
  2699  func (it *ERC20MintableApprovalIterator) Close() error {
  2700  	it.sub.Unsubscribe()
  2701  	return nil
  2702  }
  2703  
  2704  // ERC20MintableApproval represents a Approval event raised by the ERC20Mintable contract.
  2705  type ERC20MintableApproval struct {
  2706  	Owner   common.Address
  2707  	Spender common.Address
  2708  	Value   *big.Int
  2709  	Raw     types.Log // Blockchain specific contextual infos
  2710  }
  2711  
  2712  // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  2713  //
  2714  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  2715  func (_ERC20Mintable *ERC20MintableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20MintableApprovalIterator, error) {
  2716  
  2717  	var ownerRule []interface{}
  2718  	for _, ownerItem := range owner {
  2719  		ownerRule = append(ownerRule, ownerItem)
  2720  	}
  2721  	var spenderRule []interface{}
  2722  	for _, spenderItem := range spender {
  2723  		spenderRule = append(spenderRule, spenderItem)
  2724  	}
  2725  
  2726  	logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
  2727  	if err != nil {
  2728  		return nil, err
  2729  	}
  2730  	return &ERC20MintableApprovalIterator{contract: _ERC20Mintable.contract, event: "Approval", logs: logs, sub: sub}, nil
  2731  }
  2732  
  2733  // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  2734  //
  2735  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  2736  func (_ERC20Mintable *ERC20MintableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20MintableApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
  2737  
  2738  	var ownerRule []interface{}
  2739  	for _, ownerItem := range owner {
  2740  		ownerRule = append(ownerRule, ownerItem)
  2741  	}
  2742  	var spenderRule []interface{}
  2743  	for _, spenderItem := range spender {
  2744  		spenderRule = append(spenderRule, spenderItem)
  2745  	}
  2746  
  2747  	logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
  2748  	if err != nil {
  2749  		return nil, err
  2750  	}
  2751  	return event.NewSubscription(func(quit <-chan struct{}) error {
  2752  		defer sub.Unsubscribe()
  2753  		for {
  2754  			select {
  2755  			case log := <-logs:
  2756  				// New log arrived, parse the event and forward to the user
  2757  				event := new(ERC20MintableApproval)
  2758  				if err := _ERC20Mintable.contract.UnpackLog(event, "Approval", log); err != nil {
  2759  					return err
  2760  				}
  2761  				event.Raw = log
  2762  
  2763  				select {
  2764  				case sink <- event:
  2765  				case err := <-sub.Err():
  2766  					return err
  2767  				case <-quit:
  2768  					return nil
  2769  				}
  2770  			case err := <-sub.Err():
  2771  				return err
  2772  			case <-quit:
  2773  				return nil
  2774  			}
  2775  		}
  2776  	}), nil
  2777  }
  2778  
  2779  // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  2780  //
  2781  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  2782  func (_ERC20Mintable *ERC20MintableFilterer) ParseApproval(log types.Log) (*ERC20MintableApproval, error) {
  2783  	event := new(ERC20MintableApproval)
  2784  	if err := _ERC20Mintable.contract.UnpackLog(event, "Approval", log); err != nil {
  2785  		return nil, err
  2786  	}
  2787  	return event, nil
  2788  }
  2789  
  2790  // ERC20MintableMinterAddedIterator is returned from FilterMinterAdded and is used to iterate over the raw logs and unpacked data for MinterAdded events raised by the ERC20Mintable contract.
  2791  type ERC20MintableMinterAddedIterator struct {
  2792  	Event *ERC20MintableMinterAdded // Event containing the contract specifics and raw log
  2793  
  2794  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  2795  	event    string              // Event name to use for unpacking event data
  2796  
  2797  	logs chan types.Log        // Log channel receiving the found contract events
  2798  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  2799  	done bool                  // Whether the subscription completed delivering logs
  2800  	fail error                 // Occurred error to stop iteration
  2801  }
  2802  
  2803  // Next advances the iterator to the subsequent event, returning whether there
  2804  // are any more events found. In case of a retrieval or parsing error, false is
  2805  // returned and Error() can be queried for the exact failure.
  2806  func (it *ERC20MintableMinterAddedIterator) Next() bool {
  2807  	// If the iterator failed, stop iterating
  2808  	if it.fail != nil {
  2809  		return false
  2810  	}
  2811  	// If the iterator completed, deliver directly whatever's available
  2812  	if it.done {
  2813  		select {
  2814  		case log := <-it.logs:
  2815  			it.Event = new(ERC20MintableMinterAdded)
  2816  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2817  				it.fail = err
  2818  				return false
  2819  			}
  2820  			it.Event.Raw = log
  2821  			return true
  2822  
  2823  		default:
  2824  			return false
  2825  		}
  2826  	}
  2827  	// Iterator still in progress, wait for either a data or an error event
  2828  	select {
  2829  	case log := <-it.logs:
  2830  		it.Event = new(ERC20MintableMinterAdded)
  2831  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2832  			it.fail = err
  2833  			return false
  2834  		}
  2835  		it.Event.Raw = log
  2836  		return true
  2837  
  2838  	case err := <-it.sub.Err():
  2839  		it.done = true
  2840  		it.fail = err
  2841  		return it.Next()
  2842  	}
  2843  }
  2844  
  2845  // Error returns any retrieval or parsing error occurred during filtering.
  2846  func (it *ERC20MintableMinterAddedIterator) Error() error {
  2847  	return it.fail
  2848  }
  2849  
  2850  // Close terminates the iteration process, releasing any pending underlying
  2851  // resources.
  2852  func (it *ERC20MintableMinterAddedIterator) Close() error {
  2853  	it.sub.Unsubscribe()
  2854  	return nil
  2855  }
  2856  
  2857  // ERC20MintableMinterAdded represents a MinterAdded event raised by the ERC20Mintable contract.
  2858  type ERC20MintableMinterAdded struct {
  2859  	Account common.Address
  2860  	Raw     types.Log // Blockchain specific contextual infos
  2861  }
  2862  
  2863  // FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
  2864  //
  2865  // Solidity: event MinterAdded(address indexed account)
  2866  func (_ERC20Mintable *ERC20MintableFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*ERC20MintableMinterAddedIterator, error) {
  2867  
  2868  	var accountRule []interface{}
  2869  	for _, accountItem := range account {
  2870  		accountRule = append(accountRule, accountItem)
  2871  	}
  2872  
  2873  	logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "MinterAdded", accountRule)
  2874  	if err != nil {
  2875  		return nil, err
  2876  	}
  2877  	return &ERC20MintableMinterAddedIterator{contract: _ERC20Mintable.contract, event: "MinterAdded", logs: logs, sub: sub}, nil
  2878  }
  2879  
  2880  // WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
  2881  //
  2882  // Solidity: event MinterAdded(address indexed account)
  2883  func (_ERC20Mintable *ERC20MintableFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *ERC20MintableMinterAdded, account []common.Address) (event.Subscription, error) {
  2884  
  2885  	var accountRule []interface{}
  2886  	for _, accountItem := range account {
  2887  		accountRule = append(accountRule, accountItem)
  2888  	}
  2889  
  2890  	logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "MinterAdded", accountRule)
  2891  	if err != nil {
  2892  		return nil, err
  2893  	}
  2894  	return event.NewSubscription(func(quit <-chan struct{}) error {
  2895  		defer sub.Unsubscribe()
  2896  		for {
  2897  			select {
  2898  			case log := <-logs:
  2899  				// New log arrived, parse the event and forward to the user
  2900  				event := new(ERC20MintableMinterAdded)
  2901  				if err := _ERC20Mintable.contract.UnpackLog(event, "MinterAdded", log); err != nil {
  2902  					return err
  2903  				}
  2904  				event.Raw = log
  2905  
  2906  				select {
  2907  				case sink <- event:
  2908  				case err := <-sub.Err():
  2909  					return err
  2910  				case <-quit:
  2911  					return nil
  2912  				}
  2913  			case err := <-sub.Err():
  2914  				return err
  2915  			case <-quit:
  2916  				return nil
  2917  			}
  2918  		}
  2919  	}), nil
  2920  }
  2921  
  2922  // ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
  2923  //
  2924  // Solidity: event MinterAdded(address indexed account)
  2925  func (_ERC20Mintable *ERC20MintableFilterer) ParseMinterAdded(log types.Log) (*ERC20MintableMinterAdded, error) {
  2926  	event := new(ERC20MintableMinterAdded)
  2927  	if err := _ERC20Mintable.contract.UnpackLog(event, "MinterAdded", log); err != nil {
  2928  		return nil, err
  2929  	}
  2930  	return event, nil
  2931  }
  2932  
  2933  // ERC20MintableMinterRemovedIterator is returned from FilterMinterRemoved and is used to iterate over the raw logs and unpacked data for MinterRemoved events raised by the ERC20Mintable contract.
  2934  type ERC20MintableMinterRemovedIterator struct {
  2935  	Event *ERC20MintableMinterRemoved // Event containing the contract specifics and raw log
  2936  
  2937  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  2938  	event    string              // Event name to use for unpacking event data
  2939  
  2940  	logs chan types.Log        // Log channel receiving the found contract events
  2941  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  2942  	done bool                  // Whether the subscription completed delivering logs
  2943  	fail error                 // Occurred error to stop iteration
  2944  }
  2945  
  2946  // Next advances the iterator to the subsequent event, returning whether there
  2947  // are any more events found. In case of a retrieval or parsing error, false is
  2948  // returned and Error() can be queried for the exact failure.
  2949  func (it *ERC20MintableMinterRemovedIterator) Next() bool {
  2950  	// If the iterator failed, stop iterating
  2951  	if it.fail != nil {
  2952  		return false
  2953  	}
  2954  	// If the iterator completed, deliver directly whatever's available
  2955  	if it.done {
  2956  		select {
  2957  		case log := <-it.logs:
  2958  			it.Event = new(ERC20MintableMinterRemoved)
  2959  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2960  				it.fail = err
  2961  				return false
  2962  			}
  2963  			it.Event.Raw = log
  2964  			return true
  2965  
  2966  		default:
  2967  			return false
  2968  		}
  2969  	}
  2970  	// Iterator still in progress, wait for either a data or an error event
  2971  	select {
  2972  	case log := <-it.logs:
  2973  		it.Event = new(ERC20MintableMinterRemoved)
  2974  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2975  			it.fail = err
  2976  			return false
  2977  		}
  2978  		it.Event.Raw = log
  2979  		return true
  2980  
  2981  	case err := <-it.sub.Err():
  2982  		it.done = true
  2983  		it.fail = err
  2984  		return it.Next()
  2985  	}
  2986  }
  2987  
  2988  // Error returns any retrieval or parsing error occurred during filtering.
  2989  func (it *ERC20MintableMinterRemovedIterator) Error() error {
  2990  	return it.fail
  2991  }
  2992  
  2993  // Close terminates the iteration process, releasing any pending underlying
  2994  // resources.
  2995  func (it *ERC20MintableMinterRemovedIterator) Close() error {
  2996  	it.sub.Unsubscribe()
  2997  	return nil
  2998  }
  2999  
  3000  // ERC20MintableMinterRemoved represents a MinterRemoved event raised by the ERC20Mintable contract.
  3001  type ERC20MintableMinterRemoved struct {
  3002  	Account common.Address
  3003  	Raw     types.Log // Blockchain specific contextual infos
  3004  }
  3005  
  3006  // FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
  3007  //
  3008  // Solidity: event MinterRemoved(address indexed account)
  3009  func (_ERC20Mintable *ERC20MintableFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*ERC20MintableMinterRemovedIterator, error) {
  3010  
  3011  	var accountRule []interface{}
  3012  	for _, accountItem := range account {
  3013  		accountRule = append(accountRule, accountItem)
  3014  	}
  3015  
  3016  	logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "MinterRemoved", accountRule)
  3017  	if err != nil {
  3018  		return nil, err
  3019  	}
  3020  	return &ERC20MintableMinterRemovedIterator{contract: _ERC20Mintable.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil
  3021  }
  3022  
  3023  // WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
  3024  //
  3025  // Solidity: event MinterRemoved(address indexed account)
  3026  func (_ERC20Mintable *ERC20MintableFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *ERC20MintableMinterRemoved, account []common.Address) (event.Subscription, error) {
  3027  
  3028  	var accountRule []interface{}
  3029  	for _, accountItem := range account {
  3030  		accountRule = append(accountRule, accountItem)
  3031  	}
  3032  
  3033  	logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "MinterRemoved", accountRule)
  3034  	if err != nil {
  3035  		return nil, err
  3036  	}
  3037  	return event.NewSubscription(func(quit <-chan struct{}) error {
  3038  		defer sub.Unsubscribe()
  3039  		for {
  3040  			select {
  3041  			case log := <-logs:
  3042  				// New log arrived, parse the event and forward to the user
  3043  				event := new(ERC20MintableMinterRemoved)
  3044  				if err := _ERC20Mintable.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
  3045  					return err
  3046  				}
  3047  				event.Raw = log
  3048  
  3049  				select {
  3050  				case sink <- event:
  3051  				case err := <-sub.Err():
  3052  					return err
  3053  				case <-quit:
  3054  					return nil
  3055  				}
  3056  			case err := <-sub.Err():
  3057  				return err
  3058  			case <-quit:
  3059  				return nil
  3060  			}
  3061  		}
  3062  	}), nil
  3063  }
  3064  
  3065  // ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
  3066  //
  3067  // Solidity: event MinterRemoved(address indexed account)
  3068  func (_ERC20Mintable *ERC20MintableFilterer) ParseMinterRemoved(log types.Log) (*ERC20MintableMinterRemoved, error) {
  3069  	event := new(ERC20MintableMinterRemoved)
  3070  	if err := _ERC20Mintable.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
  3071  		return nil, err
  3072  	}
  3073  	return event, nil
  3074  }
  3075  
  3076  // ERC20MintableTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20Mintable contract.
  3077  type ERC20MintableTransferIterator struct {
  3078  	Event *ERC20MintableTransfer // Event containing the contract specifics and raw log
  3079  
  3080  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  3081  	event    string              // Event name to use for unpacking event data
  3082  
  3083  	logs chan types.Log        // Log channel receiving the found contract events
  3084  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  3085  	done bool                  // Whether the subscription completed delivering logs
  3086  	fail error                 // Occurred error to stop iteration
  3087  }
  3088  
  3089  // Next advances the iterator to the subsequent event, returning whether there
  3090  // are any more events found. In case of a retrieval or parsing error, false is
  3091  // returned and Error() can be queried for the exact failure.
  3092  func (it *ERC20MintableTransferIterator) Next() bool {
  3093  	// If the iterator failed, stop iterating
  3094  	if it.fail != nil {
  3095  		return false
  3096  	}
  3097  	// If the iterator completed, deliver directly whatever's available
  3098  	if it.done {
  3099  		select {
  3100  		case log := <-it.logs:
  3101  			it.Event = new(ERC20MintableTransfer)
  3102  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  3103  				it.fail = err
  3104  				return false
  3105  			}
  3106  			it.Event.Raw = log
  3107  			return true
  3108  
  3109  		default:
  3110  			return false
  3111  		}
  3112  	}
  3113  	// Iterator still in progress, wait for either a data or an error event
  3114  	select {
  3115  	case log := <-it.logs:
  3116  		it.Event = new(ERC20MintableTransfer)
  3117  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  3118  			it.fail = err
  3119  			return false
  3120  		}
  3121  		it.Event.Raw = log
  3122  		return true
  3123  
  3124  	case err := <-it.sub.Err():
  3125  		it.done = true
  3126  		it.fail = err
  3127  		return it.Next()
  3128  	}
  3129  }
  3130  
  3131  // Error returns any retrieval or parsing error occurred during filtering.
  3132  func (it *ERC20MintableTransferIterator) Error() error {
  3133  	return it.fail
  3134  }
  3135  
  3136  // Close terminates the iteration process, releasing any pending underlying
  3137  // resources.
  3138  func (it *ERC20MintableTransferIterator) Close() error {
  3139  	it.sub.Unsubscribe()
  3140  	return nil
  3141  }
  3142  
  3143  // ERC20MintableTransfer represents a Transfer event raised by the ERC20Mintable contract.
  3144  type ERC20MintableTransfer struct {
  3145  	From  common.Address
  3146  	To    common.Address
  3147  	Value *big.Int
  3148  	Raw   types.Log // Blockchain specific contextual infos
  3149  }
  3150  
  3151  // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  3152  //
  3153  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  3154  func (_ERC20Mintable *ERC20MintableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20MintableTransferIterator, error) {
  3155  
  3156  	var fromRule []interface{}
  3157  	for _, fromItem := range from {
  3158  		fromRule = append(fromRule, fromItem)
  3159  	}
  3160  	var toRule []interface{}
  3161  	for _, toItem := range to {
  3162  		toRule = append(toRule, toItem)
  3163  	}
  3164  
  3165  	logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
  3166  	if err != nil {
  3167  		return nil, err
  3168  	}
  3169  	return &ERC20MintableTransferIterator{contract: _ERC20Mintable.contract, event: "Transfer", logs: logs, sub: sub}, nil
  3170  }
  3171  
  3172  // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  3173  //
  3174  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  3175  func (_ERC20Mintable *ERC20MintableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20MintableTransfer, from []common.Address, to []common.Address) (event.Subscription, error) {
  3176  
  3177  	var fromRule []interface{}
  3178  	for _, fromItem := range from {
  3179  		fromRule = append(fromRule, fromItem)
  3180  	}
  3181  	var toRule []interface{}
  3182  	for _, toItem := range to {
  3183  		toRule = append(toRule, toItem)
  3184  	}
  3185  
  3186  	logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
  3187  	if err != nil {
  3188  		return nil, err
  3189  	}
  3190  	return event.NewSubscription(func(quit <-chan struct{}) error {
  3191  		defer sub.Unsubscribe()
  3192  		for {
  3193  			select {
  3194  			case log := <-logs:
  3195  				// New log arrived, parse the event and forward to the user
  3196  				event := new(ERC20MintableTransfer)
  3197  				if err := _ERC20Mintable.contract.UnpackLog(event, "Transfer", log); err != nil {
  3198  					return err
  3199  				}
  3200  				event.Raw = log
  3201  
  3202  				select {
  3203  				case sink <- event:
  3204  				case err := <-sub.Err():
  3205  					return err
  3206  				case <-quit:
  3207  					return nil
  3208  				}
  3209  			case err := <-sub.Err():
  3210  				return err
  3211  			case <-quit:
  3212  				return nil
  3213  			}
  3214  		}
  3215  	}), nil
  3216  }
  3217  
  3218  // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  3219  //
  3220  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  3221  func (_ERC20Mintable *ERC20MintableFilterer) ParseTransfer(log types.Log) (*ERC20MintableTransfer, error) {
  3222  	event := new(ERC20MintableTransfer)
  3223  	if err := _ERC20Mintable.contract.UnpackLog(event, "Transfer", log); err != nil {
  3224  		return nil, err
  3225  	}
  3226  	return event, nil
  3227  }
  3228  
  3229  // ERC20OnApproveABI is the input ABI used to generate the binding from.
  3230  const ERC20OnApproveABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"INTERFACE_ID_ON_APPROVE\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"approveAndCall\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
  3231  
  3232  // ERC20OnApproveFuncSigs maps the 4-byte function signature to its string representation.
  3233  var ERC20OnApproveFuncSigs = map[string]string{
  3234  	"6cd28f9a": "INTERFACE_ID_ON_APPROVE()",
  3235  	"dd62ed3e": "allowance(address,address)",
  3236  	"095ea7b3": "approve(address,uint256)",
  3237  	"cae9ca51": "approveAndCall(address,uint256,bytes)",
  3238  	"70a08231": "balanceOf(address)",
  3239  	"a457c2d7": "decreaseAllowance(address,uint256)",
  3240  	"39509351": "increaseAllowance(address,uint256)",
  3241  	"18160ddd": "totalSupply()",
  3242  	"a9059cbb": "transfer(address,uint256)",
  3243  	"23b872dd": "transferFrom(address,address,uint256)",
  3244  }
  3245  
  3246  // ERC20OnApproveBin is the compiled bytecode used for deploying new contracts.
  3247  var ERC20OnApproveBin = "0x6080604052610dc0806100136000396000f3fe608060405234801561001057600080fd5b506004361061009e5760003560e01c806370a082311161006657806370a0823114610184578063a457c2d7146101aa578063a9059cbb146101d6578063cae9ca5114610202578063dd62ed3e146102bd5761009e565b8063095ea7b3146100a357806318160ddd146100e357806323b872dd146100fd57806339509351146101335780636cd28f9a1461015f575b600080fd5b6100cf600480360360408110156100b957600080fd5b506001600160a01b0381351690602001356102eb565b604080519115158252519081900360200190f35b6100eb610308565b60408051918252519081900360200190f35b6100cf6004803603606081101561011357600080fd5b506001600160a01b0381358116916020810135909116906040013561030e565b6100cf6004803603604081101561014957600080fd5b506001600160a01b03813516906020013561039c565b6101676103f0565b604080516001600160e01b03199092168252519081900360200190f35b6100eb6004803603602081101561019a57600080fd5b50356001600160a01b031661040b565b6100cf600480360360408110156101c057600080fd5b506001600160a01b038135169060200135610426565b6100cf600480360360408110156101ec57600080fd5b506001600160a01b038135169060200135610494565b6100cf6004803603606081101561021857600080fd5b6001600160a01b038235169160208101359181019060608101604082013564010000000081111561024857600080fd5b82018360208201111561025a57600080fd5b8035906020019184600183028401116401000000008311171561027c57600080fd5b91908080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152509295506104a8945050505050565b6100eb600480360360408110156102d357600080fd5b506001600160a01b03813581169160200135166104c9565b60006102ff6102f86104f4565b84846104f8565b50600192915050565b60025490565b600061031b8484846105e4565b610391846103276104f4565b61038c85604051806060016040528060288152602001610cf6602891396001600160a01b038a166000908152600160205260408120906103656104f4565b6001600160a01b03168152602081019190915260400160002054919063ffffffff61074016565b6104f8565b5060015b9392505050565b60006102ff6103a96104f4565b8461038c85600160006103ba6104f4565b6001600160a01b03908116825260208083019390935260409182016000908120918c16815292529020549063ffffffff6107d716565b604051806028610cce82396028019050604051809103902081565b6001600160a01b031660009081526020819052604090205490565b60006102ff6104336104f4565b8461038c85604051806060016040528060258152602001610d67602591396001600061045d6104f4565b6001600160a01b03908116825260208083019390935260409182016000908120918d1681529252902054919063ffffffff61074016565b60006102ff6104a16104f4565b84846105e4565b60006104b484846102eb565b6104bd57600080fd5b61039533858585610831565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b3390565b6001600160a01b03831661053d5760405162461bcd60e51b8152600401808060200182810382526024815260200180610d436024913960400191505060405180910390fd5b6001600160a01b0382166105825760405162461bcd60e51b8152600401808060200182810382526022815260200180610c556022913960400191505060405180910390fd5b6001600160a01b03808416600081815260016020908152604080832094871680845294825291829020859055815185815291517f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259281900390910190a3505050565b6001600160a01b0383166106295760405162461bcd60e51b8152600401808060200182810382526025815260200180610d1e6025913960400191505060405180910390fd5b6001600160a01b03821661066e5760405162461bcd60e51b8152600401808060200182810382526023815260200180610c326023913960400191505060405180910390fd5b6106b181604051806060016040528060268152602001610ca8602691396001600160a01b038616600090815260208190526040902054919063ffffffff61074016565b6001600160a01b0380851660009081526020819052604080822093909355908416815220546106e6908263ffffffff6107d716565b6001600160a01b038084166000818152602081815260409182902094909455805185815290519193928716927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef92918290030190a3505050565b600081848411156107cf5760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b8381101561079457818101518382015260200161077c565b50505050905090810190601f1680156107c15780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b505050900390565b600082820183811015610395576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b610853836040518080610cce6028913960280190506040518091039020610a87565b61088e5760405162461bcd60e51b8152600401808060200182810382526031815260200180610c776031913960400191505060405180910390fd5b60006060846001600160a01b03166040518080610cce60289139602801905060405180910390208787878760405160240180856001600160a01b03166001600160a01b03168152602001846001600160a01b03166001600160a01b0316815260200183815260200180602001828103825283818151815260200191508051906020019080838360005b8381101561092f578181015183820152602001610917565b50505050905090810190601f16801561095c5780820380516001836020036101000a031916815260200191505b5060408051601f198184030181529181526020820180516001600160e01b03166001600160e01b0319909a16999099178952518151919890975087965094509250829150849050835b602083106109c45780518252601f1990920191602091820191016109a5565b6001836020036101000a0380198251168184511680821785525050505050509050019150506000604051808303816000865af19150503d8060008114610a26576040519150601f19603f3d011682016040523d82523d6000602084013e610a2b565b606091505b5091509150818190610a7e5760405162461bcd60e51b815260206004820181815283516024840152835190928392604490910191908501908083836000831561079457818101518382015260200161077c565b50505050505050565b6000610a9283610aa3565b801561039557506103958383610ad7565b6000610ab6826301ffc9a760e01b610ad7565b8015610ad15750610acf826001600160e01b0319610ad7565b155b92915050565b6000806000610ae68585610afd565b91509150818015610af45750805b95945050505050565b604080516001600160e01b0319831660248083019190915282518083039091018152604490910182526020810180516001600160e01b03166301ffc9a760e01b1781529151815160009384939284926060926001600160a01b038a169261753092879282918083835b60208310610b855780518252601f199092019160209182019101610b66565b6001836020036101000a0380198251168184511680821785525050505050509050019150506000604051808303818686fa925050503d8060008114610be6576040519150601f19603f3d011682016040523d82523d6000602084013e610beb565b606091505b5091509150602081511015610c095760008094509450505050610c2a565b81818060200190516020811015610c1f57600080fd5b505190955093505050505b925092905056fe45524332303a207472616e7366657220746f20746865207a65726f206164647265737345524332303a20617070726f766520746f20746865207a65726f206164647265737345524332304f6e417070726f76653a207370656e64657220646f65736e277420737570706f7274206f6e417070726f766545524332303a207472616e7366657220616d6f756e7420657863656564732062616c616e63656f6e417070726f766528616464726573732c616464726573732c75696e743235362c62797465732945524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e636545524332303a207472616e736665722066726f6d20746865207a65726f206164647265737345524332303a20617070726f76652066726f6d20746865207a65726f206164647265737345524332303a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726fa265627a7a723158205f38639f33e199b2a44d46fed86192ba1daf836a08c11f82aa877b89bb0dc9fc64736f6c634300050c0032"
  3248  
  3249  // DeployERC20OnApprove deploys a new Ethereum contract, binding an instance of ERC20OnApprove to it.
  3250  func DeployERC20OnApprove(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20OnApprove, error) {
  3251  	parsed, err := abi.JSON(strings.NewReader(ERC20OnApproveABI))
  3252  	if err != nil {
  3253  		return common.Address{}, nil, nil, err
  3254  	}
  3255  
  3256  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20OnApproveBin), backend)
  3257  	if err != nil {
  3258  		return common.Address{}, nil, nil, err
  3259  	}
  3260  	return address, tx, &ERC20OnApprove{ERC20OnApproveCaller: ERC20OnApproveCaller{contract: contract}, ERC20OnApproveTransactor: ERC20OnApproveTransactor{contract: contract}, ERC20OnApproveFilterer: ERC20OnApproveFilterer{contract: contract}}, nil
  3261  }
  3262  
  3263  // ERC20OnApprove is an auto generated Go binding around an Ethereum contract.
  3264  type ERC20OnApprove struct {
  3265  	ERC20OnApproveCaller     // Read-only binding to the contract
  3266  	ERC20OnApproveTransactor // Write-only binding to the contract
  3267  	ERC20OnApproveFilterer   // Log filterer for contract events
  3268  }
  3269  
  3270  // ERC20OnApproveCaller is an auto generated read-only Go binding around an Ethereum contract.
  3271  type ERC20OnApproveCaller struct {
  3272  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  3273  }
  3274  
  3275  // ERC20OnApproveTransactor is an auto generated write-only Go binding around an Ethereum contract.
  3276  type ERC20OnApproveTransactor struct {
  3277  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  3278  }
  3279  
  3280  // ERC20OnApproveFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  3281  type ERC20OnApproveFilterer struct {
  3282  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  3283  }
  3284  
  3285  // ERC20OnApproveSession is an auto generated Go binding around an Ethereum contract,
  3286  // with pre-set call and transact options.
  3287  type ERC20OnApproveSession struct {
  3288  	Contract     *ERC20OnApprove   // Generic contract binding to set the session for
  3289  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  3290  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  3291  }
  3292  
  3293  // ERC20OnApproveCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  3294  // with pre-set call options.
  3295  type ERC20OnApproveCallerSession struct {
  3296  	Contract *ERC20OnApproveCaller // Generic contract caller binding to set the session for
  3297  	CallOpts bind.CallOpts         // Call options to use throughout this session
  3298  }
  3299  
  3300  // ERC20OnApproveTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  3301  // with pre-set transact options.
  3302  type ERC20OnApproveTransactorSession struct {
  3303  	Contract     *ERC20OnApproveTransactor // Generic contract transactor binding to set the session for
  3304  	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
  3305  }
  3306  
  3307  // ERC20OnApproveRaw is an auto generated low-level Go binding around an Ethereum contract.
  3308  type ERC20OnApproveRaw struct {
  3309  	Contract *ERC20OnApprove // Generic contract binding to access the raw methods on
  3310  }
  3311  
  3312  // ERC20OnApproveCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  3313  type ERC20OnApproveCallerRaw struct {
  3314  	Contract *ERC20OnApproveCaller // Generic read-only contract binding to access the raw methods on
  3315  }
  3316  
  3317  // ERC20OnApproveTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  3318  type ERC20OnApproveTransactorRaw struct {
  3319  	Contract *ERC20OnApproveTransactor // Generic write-only contract binding to access the raw methods on
  3320  }
  3321  
  3322  // NewERC20OnApprove creates a new instance of ERC20OnApprove, bound to a specific deployed contract.
  3323  func NewERC20OnApprove(address common.Address, backend bind.ContractBackend) (*ERC20OnApprove, error) {
  3324  	contract, err := bindERC20OnApprove(address, backend, backend, backend)
  3325  	if err != nil {
  3326  		return nil, err
  3327  	}
  3328  	return &ERC20OnApprove{ERC20OnApproveCaller: ERC20OnApproveCaller{contract: contract}, ERC20OnApproveTransactor: ERC20OnApproveTransactor{contract: contract}, ERC20OnApproveFilterer: ERC20OnApproveFilterer{contract: contract}}, nil
  3329  }
  3330  
  3331  // NewERC20OnApproveCaller creates a new read-only instance of ERC20OnApprove, bound to a specific deployed contract.
  3332  func NewERC20OnApproveCaller(address common.Address, caller bind.ContractCaller) (*ERC20OnApproveCaller, error) {
  3333  	contract, err := bindERC20OnApprove(address, caller, nil, nil)
  3334  	if err != nil {
  3335  		return nil, err
  3336  	}
  3337  	return &ERC20OnApproveCaller{contract: contract}, nil
  3338  }
  3339  
  3340  // NewERC20OnApproveTransactor creates a new write-only instance of ERC20OnApprove, bound to a specific deployed contract.
  3341  func NewERC20OnApproveTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20OnApproveTransactor, error) {
  3342  	contract, err := bindERC20OnApprove(address, nil, transactor, nil)
  3343  	if err != nil {
  3344  		return nil, err
  3345  	}
  3346  	return &ERC20OnApproveTransactor{contract: contract}, nil
  3347  }
  3348  
  3349  // NewERC20OnApproveFilterer creates a new log filterer instance of ERC20OnApprove, bound to a specific deployed contract.
  3350  func NewERC20OnApproveFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20OnApproveFilterer, error) {
  3351  	contract, err := bindERC20OnApprove(address, nil, nil, filterer)
  3352  	if err != nil {
  3353  		return nil, err
  3354  	}
  3355  	return &ERC20OnApproveFilterer{contract: contract}, nil
  3356  }
  3357  
  3358  // bindERC20OnApprove binds a generic wrapper to an already deployed contract.
  3359  func bindERC20OnApprove(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  3360  	parsed, err := abi.JSON(strings.NewReader(ERC20OnApproveABI))
  3361  	if err != nil {
  3362  		return nil, err
  3363  	}
  3364  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  3365  }
  3366  
  3367  // Call invokes the (constant) contract method with params as input values and
  3368  // sets the output to result. The result type might be a single field for simple
  3369  // returns, a slice of interfaces for anonymous returns and a struct for named
  3370  // returns.
  3371  func (_ERC20OnApprove *ERC20OnApproveRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  3372  	return _ERC20OnApprove.Contract.ERC20OnApproveCaller.contract.Call(opts, result, method, params...)
  3373  }
  3374  
  3375  // Transfer initiates a plain transaction to move funds to the contract, calling
  3376  // its default method if one is available.
  3377  func (_ERC20OnApprove *ERC20OnApproveRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  3378  	return _ERC20OnApprove.Contract.ERC20OnApproveTransactor.contract.Transfer(opts)
  3379  }
  3380  
  3381  // Transact invokes the (paid) contract method with params as input values.
  3382  func (_ERC20OnApprove *ERC20OnApproveRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  3383  	return _ERC20OnApprove.Contract.ERC20OnApproveTransactor.contract.Transact(opts, method, params...)
  3384  }
  3385  
  3386  // Call invokes the (constant) contract method with params as input values and
  3387  // sets the output to result. The result type might be a single field for simple
  3388  // returns, a slice of interfaces for anonymous returns and a struct for named
  3389  // returns.
  3390  func (_ERC20OnApprove *ERC20OnApproveCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  3391  	return _ERC20OnApprove.Contract.contract.Call(opts, result, method, params...)
  3392  }
  3393  
  3394  // Transfer initiates a plain transaction to move funds to the contract, calling
  3395  // its default method if one is available.
  3396  func (_ERC20OnApprove *ERC20OnApproveTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  3397  	return _ERC20OnApprove.Contract.contract.Transfer(opts)
  3398  }
  3399  
  3400  // Transact invokes the (paid) contract method with params as input values.
  3401  func (_ERC20OnApprove *ERC20OnApproveTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  3402  	return _ERC20OnApprove.Contract.contract.Transact(opts, method, params...)
  3403  }
  3404  
  3405  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  3406  //
  3407  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  3408  func (_ERC20OnApprove *ERC20OnApproveCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) {
  3409  	var (
  3410  		ret0 = new([4]byte)
  3411  	)
  3412  	out := ret0
  3413  	err := _ERC20OnApprove.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE")
  3414  	return *ret0, err
  3415  }
  3416  
  3417  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  3418  //
  3419  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  3420  func (_ERC20OnApprove *ERC20OnApproveSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  3421  	return _ERC20OnApprove.Contract.INTERFACEIDONAPPROVE(&_ERC20OnApprove.CallOpts)
  3422  }
  3423  
  3424  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  3425  //
  3426  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  3427  func (_ERC20OnApprove *ERC20OnApproveCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  3428  	return _ERC20OnApprove.Contract.INTERFACEIDONAPPROVE(&_ERC20OnApprove.CallOpts)
  3429  }
  3430  
  3431  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  3432  //
  3433  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  3434  func (_ERC20OnApprove *ERC20OnApproveCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
  3435  	var (
  3436  		ret0 = new(*big.Int)
  3437  	)
  3438  	out := ret0
  3439  	err := _ERC20OnApprove.contract.Call(opts, out, "allowance", owner, spender)
  3440  	return *ret0, err
  3441  }
  3442  
  3443  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  3444  //
  3445  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  3446  func (_ERC20OnApprove *ERC20OnApproveSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  3447  	return _ERC20OnApprove.Contract.Allowance(&_ERC20OnApprove.CallOpts, owner, spender)
  3448  }
  3449  
  3450  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  3451  //
  3452  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  3453  func (_ERC20OnApprove *ERC20OnApproveCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  3454  	return _ERC20OnApprove.Contract.Allowance(&_ERC20OnApprove.CallOpts, owner, spender)
  3455  }
  3456  
  3457  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  3458  //
  3459  // Solidity: function balanceOf(address account) constant returns(uint256)
  3460  func (_ERC20OnApprove *ERC20OnApproveCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  3461  	var (
  3462  		ret0 = new(*big.Int)
  3463  	)
  3464  	out := ret0
  3465  	err := _ERC20OnApprove.contract.Call(opts, out, "balanceOf", account)
  3466  	return *ret0, err
  3467  }
  3468  
  3469  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  3470  //
  3471  // Solidity: function balanceOf(address account) constant returns(uint256)
  3472  func (_ERC20OnApprove *ERC20OnApproveSession) BalanceOf(account common.Address) (*big.Int, error) {
  3473  	return _ERC20OnApprove.Contract.BalanceOf(&_ERC20OnApprove.CallOpts, account)
  3474  }
  3475  
  3476  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  3477  //
  3478  // Solidity: function balanceOf(address account) constant returns(uint256)
  3479  func (_ERC20OnApprove *ERC20OnApproveCallerSession) BalanceOf(account common.Address) (*big.Int, error) {
  3480  	return _ERC20OnApprove.Contract.BalanceOf(&_ERC20OnApprove.CallOpts, account)
  3481  }
  3482  
  3483  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  3484  //
  3485  // Solidity: function totalSupply() constant returns(uint256)
  3486  func (_ERC20OnApprove *ERC20OnApproveCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
  3487  	var (
  3488  		ret0 = new(*big.Int)
  3489  	)
  3490  	out := ret0
  3491  	err := _ERC20OnApprove.contract.Call(opts, out, "totalSupply")
  3492  	return *ret0, err
  3493  }
  3494  
  3495  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  3496  //
  3497  // Solidity: function totalSupply() constant returns(uint256)
  3498  func (_ERC20OnApprove *ERC20OnApproveSession) TotalSupply() (*big.Int, error) {
  3499  	return _ERC20OnApprove.Contract.TotalSupply(&_ERC20OnApprove.CallOpts)
  3500  }
  3501  
  3502  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  3503  //
  3504  // Solidity: function totalSupply() constant returns(uint256)
  3505  func (_ERC20OnApprove *ERC20OnApproveCallerSession) TotalSupply() (*big.Int, error) {
  3506  	return _ERC20OnApprove.Contract.TotalSupply(&_ERC20OnApprove.CallOpts)
  3507  }
  3508  
  3509  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  3510  //
  3511  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  3512  func (_ERC20OnApprove *ERC20OnApproveTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
  3513  	return _ERC20OnApprove.contract.Transact(opts, "approve", spender, amount)
  3514  }
  3515  
  3516  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  3517  //
  3518  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  3519  func (_ERC20OnApprove *ERC20OnApproveSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  3520  	return _ERC20OnApprove.Contract.Approve(&_ERC20OnApprove.TransactOpts, spender, amount)
  3521  }
  3522  
  3523  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  3524  //
  3525  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  3526  func (_ERC20OnApprove *ERC20OnApproveTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  3527  	return _ERC20OnApprove.Contract.Approve(&_ERC20OnApprove.TransactOpts, spender, amount)
  3528  }
  3529  
  3530  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
  3531  //
  3532  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
  3533  func (_ERC20OnApprove *ERC20OnApproveTransactor) ApproveAndCall(opts *bind.TransactOpts, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  3534  	return _ERC20OnApprove.contract.Transact(opts, "approveAndCall", spender, amount, data)
  3535  }
  3536  
  3537  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
  3538  //
  3539  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
  3540  func (_ERC20OnApprove *ERC20OnApproveSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  3541  	return _ERC20OnApprove.Contract.ApproveAndCall(&_ERC20OnApprove.TransactOpts, spender, amount, data)
  3542  }
  3543  
  3544  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
  3545  //
  3546  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
  3547  func (_ERC20OnApprove *ERC20OnApproveTransactorSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  3548  	return _ERC20OnApprove.Contract.ApproveAndCall(&_ERC20OnApprove.TransactOpts, spender, amount, data)
  3549  }
  3550  
  3551  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  3552  //
  3553  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  3554  func (_ERC20OnApprove *ERC20OnApproveTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  3555  	return _ERC20OnApprove.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
  3556  }
  3557  
  3558  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  3559  //
  3560  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  3561  func (_ERC20OnApprove *ERC20OnApproveSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  3562  	return _ERC20OnApprove.Contract.DecreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, subtractedValue)
  3563  }
  3564  
  3565  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  3566  //
  3567  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  3568  func (_ERC20OnApprove *ERC20OnApproveTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  3569  	return _ERC20OnApprove.Contract.DecreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, subtractedValue)
  3570  }
  3571  
  3572  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  3573  //
  3574  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  3575  func (_ERC20OnApprove *ERC20OnApproveTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  3576  	return _ERC20OnApprove.contract.Transact(opts, "increaseAllowance", spender, addedValue)
  3577  }
  3578  
  3579  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  3580  //
  3581  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  3582  func (_ERC20OnApprove *ERC20OnApproveSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  3583  	return _ERC20OnApprove.Contract.IncreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, addedValue)
  3584  }
  3585  
  3586  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  3587  //
  3588  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  3589  func (_ERC20OnApprove *ERC20OnApproveTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  3590  	return _ERC20OnApprove.Contract.IncreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, addedValue)
  3591  }
  3592  
  3593  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  3594  //
  3595  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  3596  func (_ERC20OnApprove *ERC20OnApproveTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  3597  	return _ERC20OnApprove.contract.Transact(opts, "transfer", recipient, amount)
  3598  }
  3599  
  3600  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  3601  //
  3602  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  3603  func (_ERC20OnApprove *ERC20OnApproveSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  3604  	return _ERC20OnApprove.Contract.Transfer(&_ERC20OnApprove.TransactOpts, recipient, amount)
  3605  }
  3606  
  3607  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  3608  //
  3609  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  3610  func (_ERC20OnApprove *ERC20OnApproveTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  3611  	return _ERC20OnApprove.Contract.Transfer(&_ERC20OnApprove.TransactOpts, recipient, amount)
  3612  }
  3613  
  3614  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  3615  //
  3616  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  3617  func (_ERC20OnApprove *ERC20OnApproveTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  3618  	return _ERC20OnApprove.contract.Transact(opts, "transferFrom", sender, recipient, amount)
  3619  }
  3620  
  3621  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  3622  //
  3623  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  3624  func (_ERC20OnApprove *ERC20OnApproveSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  3625  	return _ERC20OnApprove.Contract.TransferFrom(&_ERC20OnApprove.TransactOpts, sender, recipient, amount)
  3626  }
  3627  
  3628  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  3629  //
  3630  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  3631  func (_ERC20OnApprove *ERC20OnApproveTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  3632  	return _ERC20OnApprove.Contract.TransferFrom(&_ERC20OnApprove.TransactOpts, sender, recipient, amount)
  3633  }
  3634  
  3635  // ERC20OnApproveApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20OnApprove contract.
  3636  type ERC20OnApproveApprovalIterator struct {
  3637  	Event *ERC20OnApproveApproval // Event containing the contract specifics and raw log
  3638  
  3639  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  3640  	event    string              // Event name to use for unpacking event data
  3641  
  3642  	logs chan types.Log        // Log channel receiving the found contract events
  3643  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  3644  	done bool                  // Whether the subscription completed delivering logs
  3645  	fail error                 // Occurred error to stop iteration
  3646  }
  3647  
  3648  // Next advances the iterator to the subsequent event, returning whether there
  3649  // are any more events found. In case of a retrieval or parsing error, false is
  3650  // returned and Error() can be queried for the exact failure.
  3651  func (it *ERC20OnApproveApprovalIterator) Next() bool {
  3652  	// If the iterator failed, stop iterating
  3653  	if it.fail != nil {
  3654  		return false
  3655  	}
  3656  	// If the iterator completed, deliver directly whatever's available
  3657  	if it.done {
  3658  		select {
  3659  		case log := <-it.logs:
  3660  			it.Event = new(ERC20OnApproveApproval)
  3661  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  3662  				it.fail = err
  3663  				return false
  3664  			}
  3665  			it.Event.Raw = log
  3666  			return true
  3667  
  3668  		default:
  3669  			return false
  3670  		}
  3671  	}
  3672  	// Iterator still in progress, wait for either a data or an error event
  3673  	select {
  3674  	case log := <-it.logs:
  3675  		it.Event = new(ERC20OnApproveApproval)
  3676  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  3677  			it.fail = err
  3678  			return false
  3679  		}
  3680  		it.Event.Raw = log
  3681  		return true
  3682  
  3683  	case err := <-it.sub.Err():
  3684  		it.done = true
  3685  		it.fail = err
  3686  		return it.Next()
  3687  	}
  3688  }
  3689  
  3690  // Error returns any retrieval or parsing error occurred during filtering.
  3691  func (it *ERC20OnApproveApprovalIterator) Error() error {
  3692  	return it.fail
  3693  }
  3694  
  3695  // Close terminates the iteration process, releasing any pending underlying
  3696  // resources.
  3697  func (it *ERC20OnApproveApprovalIterator) Close() error {
  3698  	it.sub.Unsubscribe()
  3699  	return nil
  3700  }
  3701  
  3702  // ERC20OnApproveApproval represents a Approval event raised by the ERC20OnApprove contract.
  3703  type ERC20OnApproveApproval struct {
  3704  	Owner   common.Address
  3705  	Spender common.Address
  3706  	Value   *big.Int
  3707  	Raw     types.Log // Blockchain specific contextual infos
  3708  }
  3709  
  3710  // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  3711  //
  3712  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  3713  func (_ERC20OnApprove *ERC20OnApproveFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20OnApproveApprovalIterator, error) {
  3714  
  3715  	var ownerRule []interface{}
  3716  	for _, ownerItem := range owner {
  3717  		ownerRule = append(ownerRule, ownerItem)
  3718  	}
  3719  	var spenderRule []interface{}
  3720  	for _, spenderItem := range spender {
  3721  		spenderRule = append(spenderRule, spenderItem)
  3722  	}
  3723  
  3724  	logs, sub, err := _ERC20OnApprove.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
  3725  	if err != nil {
  3726  		return nil, err
  3727  	}
  3728  	return &ERC20OnApproveApprovalIterator{contract: _ERC20OnApprove.contract, event: "Approval", logs: logs, sub: sub}, nil
  3729  }
  3730  
  3731  // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  3732  //
  3733  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  3734  func (_ERC20OnApprove *ERC20OnApproveFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20OnApproveApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
  3735  
  3736  	var ownerRule []interface{}
  3737  	for _, ownerItem := range owner {
  3738  		ownerRule = append(ownerRule, ownerItem)
  3739  	}
  3740  	var spenderRule []interface{}
  3741  	for _, spenderItem := range spender {
  3742  		spenderRule = append(spenderRule, spenderItem)
  3743  	}
  3744  
  3745  	logs, sub, err := _ERC20OnApprove.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
  3746  	if err != nil {
  3747  		return nil, err
  3748  	}
  3749  	return event.NewSubscription(func(quit <-chan struct{}) error {
  3750  		defer sub.Unsubscribe()
  3751  		for {
  3752  			select {
  3753  			case log := <-logs:
  3754  				// New log arrived, parse the event and forward to the user
  3755  				event := new(ERC20OnApproveApproval)
  3756  				if err := _ERC20OnApprove.contract.UnpackLog(event, "Approval", log); err != nil {
  3757  					return err
  3758  				}
  3759  				event.Raw = log
  3760  
  3761  				select {
  3762  				case sink <- event:
  3763  				case err := <-sub.Err():
  3764  					return err
  3765  				case <-quit:
  3766  					return nil
  3767  				}
  3768  			case err := <-sub.Err():
  3769  				return err
  3770  			case <-quit:
  3771  				return nil
  3772  			}
  3773  		}
  3774  	}), nil
  3775  }
  3776  
  3777  // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  3778  //
  3779  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  3780  func (_ERC20OnApprove *ERC20OnApproveFilterer) ParseApproval(log types.Log) (*ERC20OnApproveApproval, error) {
  3781  	event := new(ERC20OnApproveApproval)
  3782  	if err := _ERC20OnApprove.contract.UnpackLog(event, "Approval", log); err != nil {
  3783  		return nil, err
  3784  	}
  3785  	return event, nil
  3786  }
  3787  
  3788  // ERC20OnApproveTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20OnApprove contract.
  3789  type ERC20OnApproveTransferIterator struct {
  3790  	Event *ERC20OnApproveTransfer // Event containing the contract specifics and raw log
  3791  
  3792  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  3793  	event    string              // Event name to use for unpacking event data
  3794  
  3795  	logs chan types.Log        // Log channel receiving the found contract events
  3796  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  3797  	done bool                  // Whether the subscription completed delivering logs
  3798  	fail error                 // Occurred error to stop iteration
  3799  }
  3800  
  3801  // Next advances the iterator to the subsequent event, returning whether there
  3802  // are any more events found. In case of a retrieval or parsing error, false is
  3803  // returned and Error() can be queried for the exact failure.
  3804  func (it *ERC20OnApproveTransferIterator) Next() bool {
  3805  	// If the iterator failed, stop iterating
  3806  	if it.fail != nil {
  3807  		return false
  3808  	}
  3809  	// If the iterator completed, deliver directly whatever's available
  3810  	if it.done {
  3811  		select {
  3812  		case log := <-it.logs:
  3813  			it.Event = new(ERC20OnApproveTransfer)
  3814  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  3815  				it.fail = err
  3816  				return false
  3817  			}
  3818  			it.Event.Raw = log
  3819  			return true
  3820  
  3821  		default:
  3822  			return false
  3823  		}
  3824  	}
  3825  	// Iterator still in progress, wait for either a data or an error event
  3826  	select {
  3827  	case log := <-it.logs:
  3828  		it.Event = new(ERC20OnApproveTransfer)
  3829  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  3830  			it.fail = err
  3831  			return false
  3832  		}
  3833  		it.Event.Raw = log
  3834  		return true
  3835  
  3836  	case err := <-it.sub.Err():
  3837  		it.done = true
  3838  		it.fail = err
  3839  		return it.Next()
  3840  	}
  3841  }
  3842  
  3843  // Error returns any retrieval or parsing error occurred during filtering.
  3844  func (it *ERC20OnApproveTransferIterator) Error() error {
  3845  	return it.fail
  3846  }
  3847  
  3848  // Close terminates the iteration process, releasing any pending underlying
  3849  // resources.
  3850  func (it *ERC20OnApproveTransferIterator) Close() error {
  3851  	it.sub.Unsubscribe()
  3852  	return nil
  3853  }
  3854  
  3855  // ERC20OnApproveTransfer represents a Transfer event raised by the ERC20OnApprove contract.
  3856  type ERC20OnApproveTransfer struct {
  3857  	From  common.Address
  3858  	To    common.Address
  3859  	Value *big.Int
  3860  	Raw   types.Log // Blockchain specific contextual infos
  3861  }
  3862  
  3863  // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  3864  //
  3865  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  3866  func (_ERC20OnApprove *ERC20OnApproveFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20OnApproveTransferIterator, error) {
  3867  
  3868  	var fromRule []interface{}
  3869  	for _, fromItem := range from {
  3870  		fromRule = append(fromRule, fromItem)
  3871  	}
  3872  	var toRule []interface{}
  3873  	for _, toItem := range to {
  3874  		toRule = append(toRule, toItem)
  3875  	}
  3876  
  3877  	logs, sub, err := _ERC20OnApprove.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
  3878  	if err != nil {
  3879  		return nil, err
  3880  	}
  3881  	return &ERC20OnApproveTransferIterator{contract: _ERC20OnApprove.contract, event: "Transfer", logs: logs, sub: sub}, nil
  3882  }
  3883  
  3884  // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  3885  //
  3886  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  3887  func (_ERC20OnApprove *ERC20OnApproveFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20OnApproveTransfer, from []common.Address, to []common.Address) (event.Subscription, error) {
  3888  
  3889  	var fromRule []interface{}
  3890  	for _, fromItem := range from {
  3891  		fromRule = append(fromRule, fromItem)
  3892  	}
  3893  	var toRule []interface{}
  3894  	for _, toItem := range to {
  3895  		toRule = append(toRule, toItem)
  3896  	}
  3897  
  3898  	logs, sub, err := _ERC20OnApprove.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
  3899  	if err != nil {
  3900  		return nil, err
  3901  	}
  3902  	return event.NewSubscription(func(quit <-chan struct{}) error {
  3903  		defer sub.Unsubscribe()
  3904  		for {
  3905  			select {
  3906  			case log := <-logs:
  3907  				// New log arrived, parse the event and forward to the user
  3908  				event := new(ERC20OnApproveTransfer)
  3909  				if err := _ERC20OnApprove.contract.UnpackLog(event, "Transfer", log); err != nil {
  3910  					return err
  3911  				}
  3912  				event.Raw = log
  3913  
  3914  				select {
  3915  				case sink <- event:
  3916  				case err := <-sub.Err():
  3917  					return err
  3918  				case <-quit:
  3919  					return nil
  3920  				}
  3921  			case err := <-sub.Err():
  3922  				return err
  3923  			case <-quit:
  3924  				return nil
  3925  			}
  3926  		}
  3927  	}), nil
  3928  }
  3929  
  3930  // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  3931  //
  3932  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  3933  func (_ERC20OnApprove *ERC20OnApproveFilterer) ParseTransfer(log types.Log) (*ERC20OnApproveTransfer, error) {
  3934  	event := new(ERC20OnApproveTransfer)
  3935  	if err := _ERC20OnApprove.contract.UnpackLog(event, "Transfer", log); err != nil {
  3936  		return nil, err
  3937  	}
  3938  	return event, nil
  3939  }
  3940  
  3941  // IERC20ABI is the input ABI used to generate the binding from.
  3942  const IERC20ABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
  3943  
  3944  // IERC20FuncSigs maps the 4-byte function signature to its string representation.
  3945  var IERC20FuncSigs = map[string]string{
  3946  	"dd62ed3e": "allowance(address,address)",
  3947  	"095ea7b3": "approve(address,uint256)",
  3948  	"70a08231": "balanceOf(address)",
  3949  	"18160ddd": "totalSupply()",
  3950  	"a9059cbb": "transfer(address,uint256)",
  3951  	"23b872dd": "transferFrom(address,address,uint256)",
  3952  }
  3953  
  3954  // IERC20 is an auto generated Go binding around an Ethereum contract.
  3955  type IERC20 struct {
  3956  	IERC20Caller     // Read-only binding to the contract
  3957  	IERC20Transactor // Write-only binding to the contract
  3958  	IERC20Filterer   // Log filterer for contract events
  3959  }
  3960  
  3961  // IERC20Caller is an auto generated read-only Go binding around an Ethereum contract.
  3962  type IERC20Caller struct {
  3963  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  3964  }
  3965  
  3966  // IERC20Transactor is an auto generated write-only Go binding around an Ethereum contract.
  3967  type IERC20Transactor struct {
  3968  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  3969  }
  3970  
  3971  // IERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
  3972  type IERC20Filterer struct {
  3973  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  3974  }
  3975  
  3976  // IERC20Session is an auto generated Go binding around an Ethereum contract,
  3977  // with pre-set call and transact options.
  3978  type IERC20Session struct {
  3979  	Contract     *IERC20           // Generic contract binding to set the session for
  3980  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  3981  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  3982  }
  3983  
  3984  // IERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract,
  3985  // with pre-set call options.
  3986  type IERC20CallerSession struct {
  3987  	Contract *IERC20Caller // Generic contract caller binding to set the session for
  3988  	CallOpts bind.CallOpts // Call options to use throughout this session
  3989  }
  3990  
  3991  // IERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  3992  // with pre-set transact options.
  3993  type IERC20TransactorSession struct {
  3994  	Contract     *IERC20Transactor // Generic contract transactor binding to set the session for
  3995  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  3996  }
  3997  
  3998  // IERC20Raw is an auto generated low-level Go binding around an Ethereum contract.
  3999  type IERC20Raw struct {
  4000  	Contract *IERC20 // Generic contract binding to access the raw methods on
  4001  }
  4002  
  4003  // IERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  4004  type IERC20CallerRaw struct {
  4005  	Contract *IERC20Caller // Generic read-only contract binding to access the raw methods on
  4006  }
  4007  
  4008  // IERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  4009  type IERC20TransactorRaw struct {
  4010  	Contract *IERC20Transactor // Generic write-only contract binding to access the raw methods on
  4011  }
  4012  
  4013  // NewIERC20 creates a new instance of IERC20, bound to a specific deployed contract.
  4014  func NewIERC20(address common.Address, backend bind.ContractBackend) (*IERC20, error) {
  4015  	contract, err := bindIERC20(address, backend, backend, backend)
  4016  	if err != nil {
  4017  		return nil, err
  4018  	}
  4019  	return &IERC20{IERC20Caller: IERC20Caller{contract: contract}, IERC20Transactor: IERC20Transactor{contract: contract}, IERC20Filterer: IERC20Filterer{contract: contract}}, nil
  4020  }
  4021  
  4022  // NewIERC20Caller creates a new read-only instance of IERC20, bound to a specific deployed contract.
  4023  func NewIERC20Caller(address common.Address, caller bind.ContractCaller) (*IERC20Caller, error) {
  4024  	contract, err := bindIERC20(address, caller, nil, nil)
  4025  	if err != nil {
  4026  		return nil, err
  4027  	}
  4028  	return &IERC20Caller{contract: contract}, nil
  4029  }
  4030  
  4031  // NewIERC20Transactor creates a new write-only instance of IERC20, bound to a specific deployed contract.
  4032  func NewIERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC20Transactor, error) {
  4033  	contract, err := bindIERC20(address, nil, transactor, nil)
  4034  	if err != nil {
  4035  		return nil, err
  4036  	}
  4037  	return &IERC20Transactor{contract: contract}, nil
  4038  }
  4039  
  4040  // NewIERC20Filterer creates a new log filterer instance of IERC20, bound to a specific deployed contract.
  4041  func NewIERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC20Filterer, error) {
  4042  	contract, err := bindIERC20(address, nil, nil, filterer)
  4043  	if err != nil {
  4044  		return nil, err
  4045  	}
  4046  	return &IERC20Filterer{contract: contract}, nil
  4047  }
  4048  
  4049  // bindIERC20 binds a generic wrapper to an already deployed contract.
  4050  func bindIERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  4051  	parsed, err := abi.JSON(strings.NewReader(IERC20ABI))
  4052  	if err != nil {
  4053  		return nil, err
  4054  	}
  4055  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  4056  }
  4057  
  4058  // Call invokes the (constant) contract method with params as input values and
  4059  // sets the output to result. The result type might be a single field for simple
  4060  // returns, a slice of interfaces for anonymous returns and a struct for named
  4061  // returns.
  4062  func (_IERC20 *IERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  4063  	return _IERC20.Contract.IERC20Caller.contract.Call(opts, result, method, params...)
  4064  }
  4065  
  4066  // Transfer initiates a plain transaction to move funds to the contract, calling
  4067  // its default method if one is available.
  4068  func (_IERC20 *IERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  4069  	return _IERC20.Contract.IERC20Transactor.contract.Transfer(opts)
  4070  }
  4071  
  4072  // Transact invokes the (paid) contract method with params as input values.
  4073  func (_IERC20 *IERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  4074  	return _IERC20.Contract.IERC20Transactor.contract.Transact(opts, method, params...)
  4075  }
  4076  
  4077  // Call invokes the (constant) contract method with params as input values and
  4078  // sets the output to result. The result type might be a single field for simple
  4079  // returns, a slice of interfaces for anonymous returns and a struct for named
  4080  // returns.
  4081  func (_IERC20 *IERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  4082  	return _IERC20.Contract.contract.Call(opts, result, method, params...)
  4083  }
  4084  
  4085  // Transfer initiates a plain transaction to move funds to the contract, calling
  4086  // its default method if one is available.
  4087  func (_IERC20 *IERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  4088  	return _IERC20.Contract.contract.Transfer(opts)
  4089  }
  4090  
  4091  // Transact invokes the (paid) contract method with params as input values.
  4092  func (_IERC20 *IERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  4093  	return _IERC20.Contract.contract.Transact(opts, method, params...)
  4094  }
  4095  
  4096  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  4097  //
  4098  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  4099  func (_IERC20 *IERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
  4100  	var (
  4101  		ret0 = new(*big.Int)
  4102  	)
  4103  	out := ret0
  4104  	err := _IERC20.contract.Call(opts, out, "allowance", owner, spender)
  4105  	return *ret0, err
  4106  }
  4107  
  4108  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  4109  //
  4110  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  4111  func (_IERC20 *IERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  4112  	return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender)
  4113  }
  4114  
  4115  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  4116  //
  4117  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  4118  func (_IERC20 *IERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  4119  	return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender)
  4120  }
  4121  
  4122  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  4123  //
  4124  // Solidity: function balanceOf(address account) constant returns(uint256)
  4125  func (_IERC20 *IERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  4126  	var (
  4127  		ret0 = new(*big.Int)
  4128  	)
  4129  	out := ret0
  4130  	err := _IERC20.contract.Call(opts, out, "balanceOf", account)
  4131  	return *ret0, err
  4132  }
  4133  
  4134  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  4135  //
  4136  // Solidity: function balanceOf(address account) constant returns(uint256)
  4137  func (_IERC20 *IERC20Session) BalanceOf(account common.Address) (*big.Int, error) {
  4138  	return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, account)
  4139  }
  4140  
  4141  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  4142  //
  4143  // Solidity: function balanceOf(address account) constant returns(uint256)
  4144  func (_IERC20 *IERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) {
  4145  	return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, account)
  4146  }
  4147  
  4148  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  4149  //
  4150  // Solidity: function totalSupply() constant returns(uint256)
  4151  func (_IERC20 *IERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
  4152  	var (
  4153  		ret0 = new(*big.Int)
  4154  	)
  4155  	out := ret0
  4156  	err := _IERC20.contract.Call(opts, out, "totalSupply")
  4157  	return *ret0, err
  4158  }
  4159  
  4160  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  4161  //
  4162  // Solidity: function totalSupply() constant returns(uint256)
  4163  func (_IERC20 *IERC20Session) TotalSupply() (*big.Int, error) {
  4164  	return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts)
  4165  }
  4166  
  4167  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  4168  //
  4169  // Solidity: function totalSupply() constant returns(uint256)
  4170  func (_IERC20 *IERC20CallerSession) TotalSupply() (*big.Int, error) {
  4171  	return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts)
  4172  }
  4173  
  4174  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  4175  //
  4176  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  4177  func (_IERC20 *IERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
  4178  	return _IERC20.contract.Transact(opts, "approve", spender, amount)
  4179  }
  4180  
  4181  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  4182  //
  4183  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  4184  func (_IERC20 *IERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  4185  	return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, amount)
  4186  }
  4187  
  4188  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  4189  //
  4190  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  4191  func (_IERC20 *IERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  4192  	return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, amount)
  4193  }
  4194  
  4195  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  4196  //
  4197  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  4198  func (_IERC20 *IERC20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4199  	return _IERC20.contract.Transact(opts, "transfer", recipient, amount)
  4200  }
  4201  
  4202  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  4203  //
  4204  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  4205  func (_IERC20 *IERC20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4206  	return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, recipient, amount)
  4207  }
  4208  
  4209  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  4210  //
  4211  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  4212  func (_IERC20 *IERC20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4213  	return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, recipient, amount)
  4214  }
  4215  
  4216  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  4217  //
  4218  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  4219  func (_IERC20 *IERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4220  	return _IERC20.contract.Transact(opts, "transferFrom", sender, recipient, amount)
  4221  }
  4222  
  4223  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  4224  //
  4225  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  4226  func (_IERC20 *IERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4227  	return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, sender, recipient, amount)
  4228  }
  4229  
  4230  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  4231  //
  4232  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  4233  func (_IERC20 *IERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4234  	return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, sender, recipient, amount)
  4235  }
  4236  
  4237  // IERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IERC20 contract.
  4238  type IERC20ApprovalIterator struct {
  4239  	Event *IERC20Approval // Event containing the contract specifics and raw log
  4240  
  4241  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  4242  	event    string              // Event name to use for unpacking event data
  4243  
  4244  	logs chan types.Log        // Log channel receiving the found contract events
  4245  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  4246  	done bool                  // Whether the subscription completed delivering logs
  4247  	fail error                 // Occurred error to stop iteration
  4248  }
  4249  
  4250  // Next advances the iterator to the subsequent event, returning whether there
  4251  // are any more events found. In case of a retrieval or parsing error, false is
  4252  // returned and Error() can be queried for the exact failure.
  4253  func (it *IERC20ApprovalIterator) Next() bool {
  4254  	// If the iterator failed, stop iterating
  4255  	if it.fail != nil {
  4256  		return false
  4257  	}
  4258  	// If the iterator completed, deliver directly whatever's available
  4259  	if it.done {
  4260  		select {
  4261  		case log := <-it.logs:
  4262  			it.Event = new(IERC20Approval)
  4263  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4264  				it.fail = err
  4265  				return false
  4266  			}
  4267  			it.Event.Raw = log
  4268  			return true
  4269  
  4270  		default:
  4271  			return false
  4272  		}
  4273  	}
  4274  	// Iterator still in progress, wait for either a data or an error event
  4275  	select {
  4276  	case log := <-it.logs:
  4277  		it.Event = new(IERC20Approval)
  4278  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4279  			it.fail = err
  4280  			return false
  4281  		}
  4282  		it.Event.Raw = log
  4283  		return true
  4284  
  4285  	case err := <-it.sub.Err():
  4286  		it.done = true
  4287  		it.fail = err
  4288  		return it.Next()
  4289  	}
  4290  }
  4291  
  4292  // Error returns any retrieval or parsing error occurred during filtering.
  4293  func (it *IERC20ApprovalIterator) Error() error {
  4294  	return it.fail
  4295  }
  4296  
  4297  // Close terminates the iteration process, releasing any pending underlying
  4298  // resources.
  4299  func (it *IERC20ApprovalIterator) Close() error {
  4300  	it.sub.Unsubscribe()
  4301  	return nil
  4302  }
  4303  
  4304  // IERC20Approval represents a Approval event raised by the IERC20 contract.
  4305  type IERC20Approval struct {
  4306  	Owner   common.Address
  4307  	Spender common.Address
  4308  	Value   *big.Int
  4309  	Raw     types.Log // Blockchain specific contextual infos
  4310  }
  4311  
  4312  // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  4313  //
  4314  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  4315  func (_IERC20 *IERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IERC20ApprovalIterator, error) {
  4316  
  4317  	var ownerRule []interface{}
  4318  	for _, ownerItem := range owner {
  4319  		ownerRule = append(ownerRule, ownerItem)
  4320  	}
  4321  	var spenderRule []interface{}
  4322  	for _, spenderItem := range spender {
  4323  		spenderRule = append(spenderRule, spenderItem)
  4324  	}
  4325  
  4326  	logs, sub, err := _IERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
  4327  	if err != nil {
  4328  		return nil, err
  4329  	}
  4330  	return &IERC20ApprovalIterator{contract: _IERC20.contract, event: "Approval", logs: logs, sub: sub}, nil
  4331  }
  4332  
  4333  // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  4334  //
  4335  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  4336  func (_IERC20 *IERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
  4337  
  4338  	var ownerRule []interface{}
  4339  	for _, ownerItem := range owner {
  4340  		ownerRule = append(ownerRule, ownerItem)
  4341  	}
  4342  	var spenderRule []interface{}
  4343  	for _, spenderItem := range spender {
  4344  		spenderRule = append(spenderRule, spenderItem)
  4345  	}
  4346  
  4347  	logs, sub, err := _IERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
  4348  	if err != nil {
  4349  		return nil, err
  4350  	}
  4351  	return event.NewSubscription(func(quit <-chan struct{}) error {
  4352  		defer sub.Unsubscribe()
  4353  		for {
  4354  			select {
  4355  			case log := <-logs:
  4356  				// New log arrived, parse the event and forward to the user
  4357  				event := new(IERC20Approval)
  4358  				if err := _IERC20.contract.UnpackLog(event, "Approval", log); err != nil {
  4359  					return err
  4360  				}
  4361  				event.Raw = log
  4362  
  4363  				select {
  4364  				case sink <- event:
  4365  				case err := <-sub.Err():
  4366  					return err
  4367  				case <-quit:
  4368  					return nil
  4369  				}
  4370  			case err := <-sub.Err():
  4371  				return err
  4372  			case <-quit:
  4373  				return nil
  4374  			}
  4375  		}
  4376  	}), nil
  4377  }
  4378  
  4379  // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  4380  //
  4381  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  4382  func (_IERC20 *IERC20Filterer) ParseApproval(log types.Log) (*IERC20Approval, error) {
  4383  	event := new(IERC20Approval)
  4384  	if err := _IERC20.contract.UnpackLog(event, "Approval", log); err != nil {
  4385  		return nil, err
  4386  	}
  4387  	return event, nil
  4388  }
  4389  
  4390  // IERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IERC20 contract.
  4391  type IERC20TransferIterator struct {
  4392  	Event *IERC20Transfer // Event containing the contract specifics and raw log
  4393  
  4394  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  4395  	event    string              // Event name to use for unpacking event data
  4396  
  4397  	logs chan types.Log        // Log channel receiving the found contract events
  4398  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  4399  	done bool                  // Whether the subscription completed delivering logs
  4400  	fail error                 // Occurred error to stop iteration
  4401  }
  4402  
  4403  // Next advances the iterator to the subsequent event, returning whether there
  4404  // are any more events found. In case of a retrieval or parsing error, false is
  4405  // returned and Error() can be queried for the exact failure.
  4406  func (it *IERC20TransferIterator) Next() bool {
  4407  	// If the iterator failed, stop iterating
  4408  	if it.fail != nil {
  4409  		return false
  4410  	}
  4411  	// If the iterator completed, deliver directly whatever's available
  4412  	if it.done {
  4413  		select {
  4414  		case log := <-it.logs:
  4415  			it.Event = new(IERC20Transfer)
  4416  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4417  				it.fail = err
  4418  				return false
  4419  			}
  4420  			it.Event.Raw = log
  4421  			return true
  4422  
  4423  		default:
  4424  			return false
  4425  		}
  4426  	}
  4427  	// Iterator still in progress, wait for either a data or an error event
  4428  	select {
  4429  	case log := <-it.logs:
  4430  		it.Event = new(IERC20Transfer)
  4431  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4432  			it.fail = err
  4433  			return false
  4434  		}
  4435  		it.Event.Raw = log
  4436  		return true
  4437  
  4438  	case err := <-it.sub.Err():
  4439  		it.done = true
  4440  		it.fail = err
  4441  		return it.Next()
  4442  	}
  4443  }
  4444  
  4445  // Error returns any retrieval or parsing error occurred during filtering.
  4446  func (it *IERC20TransferIterator) Error() error {
  4447  	return it.fail
  4448  }
  4449  
  4450  // Close terminates the iteration process, releasing any pending underlying
  4451  // resources.
  4452  func (it *IERC20TransferIterator) Close() error {
  4453  	it.sub.Unsubscribe()
  4454  	return nil
  4455  }
  4456  
  4457  // IERC20Transfer represents a Transfer event raised by the IERC20 contract.
  4458  type IERC20Transfer struct {
  4459  	From  common.Address
  4460  	To    common.Address
  4461  	Value *big.Int
  4462  	Raw   types.Log // Blockchain specific contextual infos
  4463  }
  4464  
  4465  // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  4466  //
  4467  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  4468  func (_IERC20 *IERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IERC20TransferIterator, error) {
  4469  
  4470  	var fromRule []interface{}
  4471  	for _, fromItem := range from {
  4472  		fromRule = append(fromRule, fromItem)
  4473  	}
  4474  	var toRule []interface{}
  4475  	for _, toItem := range to {
  4476  		toRule = append(toRule, toItem)
  4477  	}
  4478  
  4479  	logs, sub, err := _IERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
  4480  	if err != nil {
  4481  		return nil, err
  4482  	}
  4483  	return &IERC20TransferIterator{contract: _IERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil
  4484  }
  4485  
  4486  // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  4487  //
  4488  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  4489  func (_IERC20 *IERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) {
  4490  
  4491  	var fromRule []interface{}
  4492  	for _, fromItem := range from {
  4493  		fromRule = append(fromRule, fromItem)
  4494  	}
  4495  	var toRule []interface{}
  4496  	for _, toItem := range to {
  4497  		toRule = append(toRule, toItem)
  4498  	}
  4499  
  4500  	logs, sub, err := _IERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
  4501  	if err != nil {
  4502  		return nil, err
  4503  	}
  4504  	return event.NewSubscription(func(quit <-chan struct{}) error {
  4505  		defer sub.Unsubscribe()
  4506  		for {
  4507  			select {
  4508  			case log := <-logs:
  4509  				// New log arrived, parse the event and forward to the user
  4510  				event := new(IERC20Transfer)
  4511  				if err := _IERC20.contract.UnpackLog(event, "Transfer", log); err != nil {
  4512  					return err
  4513  				}
  4514  				event.Raw = log
  4515  
  4516  				select {
  4517  				case sink <- event:
  4518  				case err := <-sub.Err():
  4519  					return err
  4520  				case <-quit:
  4521  					return nil
  4522  				}
  4523  			case err := <-sub.Err():
  4524  				return err
  4525  			case <-quit:
  4526  				return nil
  4527  			}
  4528  		}
  4529  	}), nil
  4530  }
  4531  
  4532  // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  4533  //
  4534  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  4535  func (_IERC20 *IERC20Filterer) ParseTransfer(log types.Log) (*IERC20Transfer, error) {
  4536  	event := new(IERC20Transfer)
  4537  	if err := _IERC20.contract.UnpackLog(event, "Transfer", log); err != nil {
  4538  		return nil, err
  4539  	}
  4540  	return event, nil
  4541  }
  4542  
  4543  // MinterRoleABI is the input ABI used to generate the binding from.
  4544  const MinterRoleABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterRemoved\",\"type\":\"event\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isMinter\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
  4545  
  4546  // MinterRoleFuncSigs maps the 4-byte function signature to its string representation.
  4547  var MinterRoleFuncSigs = map[string]string{
  4548  	"983b2d56": "addMinter(address)",
  4549  	"aa271e1a": "isMinter(address)",
  4550  	"98650275": "renounceMinter()",
  4551  }
  4552  
  4553  // MinterRole is an auto generated Go binding around an Ethereum contract.
  4554  type MinterRole struct {
  4555  	MinterRoleCaller     // Read-only binding to the contract
  4556  	MinterRoleTransactor // Write-only binding to the contract
  4557  	MinterRoleFilterer   // Log filterer for contract events
  4558  }
  4559  
  4560  // MinterRoleCaller is an auto generated read-only Go binding around an Ethereum contract.
  4561  type MinterRoleCaller struct {
  4562  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  4563  }
  4564  
  4565  // MinterRoleTransactor is an auto generated write-only Go binding around an Ethereum contract.
  4566  type MinterRoleTransactor struct {
  4567  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  4568  }
  4569  
  4570  // MinterRoleFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  4571  type MinterRoleFilterer struct {
  4572  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  4573  }
  4574  
  4575  // MinterRoleSession is an auto generated Go binding around an Ethereum contract,
  4576  // with pre-set call and transact options.
  4577  type MinterRoleSession struct {
  4578  	Contract     *MinterRole       // Generic contract binding to set the session for
  4579  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  4580  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  4581  }
  4582  
  4583  // MinterRoleCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  4584  // with pre-set call options.
  4585  type MinterRoleCallerSession struct {
  4586  	Contract *MinterRoleCaller // Generic contract caller binding to set the session for
  4587  	CallOpts bind.CallOpts     // Call options to use throughout this session
  4588  }
  4589  
  4590  // MinterRoleTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  4591  // with pre-set transact options.
  4592  type MinterRoleTransactorSession struct {
  4593  	Contract     *MinterRoleTransactor // Generic contract transactor binding to set the session for
  4594  	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
  4595  }
  4596  
  4597  // MinterRoleRaw is an auto generated low-level Go binding around an Ethereum contract.
  4598  type MinterRoleRaw struct {
  4599  	Contract *MinterRole // Generic contract binding to access the raw methods on
  4600  }
  4601  
  4602  // MinterRoleCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  4603  type MinterRoleCallerRaw struct {
  4604  	Contract *MinterRoleCaller // Generic read-only contract binding to access the raw methods on
  4605  }
  4606  
  4607  // MinterRoleTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  4608  type MinterRoleTransactorRaw struct {
  4609  	Contract *MinterRoleTransactor // Generic write-only contract binding to access the raw methods on
  4610  }
  4611  
  4612  // NewMinterRole creates a new instance of MinterRole, bound to a specific deployed contract.
  4613  func NewMinterRole(address common.Address, backend bind.ContractBackend) (*MinterRole, error) {
  4614  	contract, err := bindMinterRole(address, backend, backend, backend)
  4615  	if err != nil {
  4616  		return nil, err
  4617  	}
  4618  	return &MinterRole{MinterRoleCaller: MinterRoleCaller{contract: contract}, MinterRoleTransactor: MinterRoleTransactor{contract: contract}, MinterRoleFilterer: MinterRoleFilterer{contract: contract}}, nil
  4619  }
  4620  
  4621  // NewMinterRoleCaller creates a new read-only instance of MinterRole, bound to a specific deployed contract.
  4622  func NewMinterRoleCaller(address common.Address, caller bind.ContractCaller) (*MinterRoleCaller, error) {
  4623  	contract, err := bindMinterRole(address, caller, nil, nil)
  4624  	if err != nil {
  4625  		return nil, err
  4626  	}
  4627  	return &MinterRoleCaller{contract: contract}, nil
  4628  }
  4629  
  4630  // NewMinterRoleTransactor creates a new write-only instance of MinterRole, bound to a specific deployed contract.
  4631  func NewMinterRoleTransactor(address common.Address, transactor bind.ContractTransactor) (*MinterRoleTransactor, error) {
  4632  	contract, err := bindMinterRole(address, nil, transactor, nil)
  4633  	if err != nil {
  4634  		return nil, err
  4635  	}
  4636  	return &MinterRoleTransactor{contract: contract}, nil
  4637  }
  4638  
  4639  // NewMinterRoleFilterer creates a new log filterer instance of MinterRole, bound to a specific deployed contract.
  4640  func NewMinterRoleFilterer(address common.Address, filterer bind.ContractFilterer) (*MinterRoleFilterer, error) {
  4641  	contract, err := bindMinterRole(address, nil, nil, filterer)
  4642  	if err != nil {
  4643  		return nil, err
  4644  	}
  4645  	return &MinterRoleFilterer{contract: contract}, nil
  4646  }
  4647  
  4648  // bindMinterRole binds a generic wrapper to an already deployed contract.
  4649  func bindMinterRole(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  4650  	parsed, err := abi.JSON(strings.NewReader(MinterRoleABI))
  4651  	if err != nil {
  4652  		return nil, err
  4653  	}
  4654  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  4655  }
  4656  
  4657  // Call invokes the (constant) contract method with params as input values and
  4658  // sets the output to result. The result type might be a single field for simple
  4659  // returns, a slice of interfaces for anonymous returns and a struct for named
  4660  // returns.
  4661  func (_MinterRole *MinterRoleRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  4662  	return _MinterRole.Contract.MinterRoleCaller.contract.Call(opts, result, method, params...)
  4663  }
  4664  
  4665  // Transfer initiates a plain transaction to move funds to the contract, calling
  4666  // its default method if one is available.
  4667  func (_MinterRole *MinterRoleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  4668  	return _MinterRole.Contract.MinterRoleTransactor.contract.Transfer(opts)
  4669  }
  4670  
  4671  // Transact invokes the (paid) contract method with params as input values.
  4672  func (_MinterRole *MinterRoleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  4673  	return _MinterRole.Contract.MinterRoleTransactor.contract.Transact(opts, method, params...)
  4674  }
  4675  
  4676  // Call invokes the (constant) contract method with params as input values and
  4677  // sets the output to result. The result type might be a single field for simple
  4678  // returns, a slice of interfaces for anonymous returns and a struct for named
  4679  // returns.
  4680  func (_MinterRole *MinterRoleCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  4681  	return _MinterRole.Contract.contract.Call(opts, result, method, params...)
  4682  }
  4683  
  4684  // Transfer initiates a plain transaction to move funds to the contract, calling
  4685  // its default method if one is available.
  4686  func (_MinterRole *MinterRoleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  4687  	return _MinterRole.Contract.contract.Transfer(opts)
  4688  }
  4689  
  4690  // Transact invokes the (paid) contract method with params as input values.
  4691  func (_MinterRole *MinterRoleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  4692  	return _MinterRole.Contract.contract.Transact(opts, method, params...)
  4693  }
  4694  
  4695  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
  4696  //
  4697  // Solidity: function isMinter(address account) constant returns(bool)
  4698  func (_MinterRole *MinterRoleCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) {
  4699  	var (
  4700  		ret0 = new(bool)
  4701  	)
  4702  	out := ret0
  4703  	err := _MinterRole.contract.Call(opts, out, "isMinter", account)
  4704  	return *ret0, err
  4705  }
  4706  
  4707  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
  4708  //
  4709  // Solidity: function isMinter(address account) constant returns(bool)
  4710  func (_MinterRole *MinterRoleSession) IsMinter(account common.Address) (bool, error) {
  4711  	return _MinterRole.Contract.IsMinter(&_MinterRole.CallOpts, account)
  4712  }
  4713  
  4714  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
  4715  //
  4716  // Solidity: function isMinter(address account) constant returns(bool)
  4717  func (_MinterRole *MinterRoleCallerSession) IsMinter(account common.Address) (bool, error) {
  4718  	return _MinterRole.Contract.IsMinter(&_MinterRole.CallOpts, account)
  4719  }
  4720  
  4721  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
  4722  //
  4723  // Solidity: function addMinter(address account) returns()
  4724  func (_MinterRole *MinterRoleTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
  4725  	return _MinterRole.contract.Transact(opts, "addMinter", account)
  4726  }
  4727  
  4728  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
  4729  //
  4730  // Solidity: function addMinter(address account) returns()
  4731  func (_MinterRole *MinterRoleSession) AddMinter(account common.Address) (*types.Transaction, error) {
  4732  	return _MinterRole.Contract.AddMinter(&_MinterRole.TransactOpts, account)
  4733  }
  4734  
  4735  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
  4736  //
  4737  // Solidity: function addMinter(address account) returns()
  4738  func (_MinterRole *MinterRoleTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) {
  4739  	return _MinterRole.Contract.AddMinter(&_MinterRole.TransactOpts, account)
  4740  }
  4741  
  4742  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  4743  //
  4744  // Solidity: function renounceMinter() returns()
  4745  func (_MinterRole *MinterRoleTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) {
  4746  	return _MinterRole.contract.Transact(opts, "renounceMinter")
  4747  }
  4748  
  4749  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  4750  //
  4751  // Solidity: function renounceMinter() returns()
  4752  func (_MinterRole *MinterRoleSession) RenounceMinter() (*types.Transaction, error) {
  4753  	return _MinterRole.Contract.RenounceMinter(&_MinterRole.TransactOpts)
  4754  }
  4755  
  4756  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  4757  //
  4758  // Solidity: function renounceMinter() returns()
  4759  func (_MinterRole *MinterRoleTransactorSession) RenounceMinter() (*types.Transaction, error) {
  4760  	return _MinterRole.Contract.RenounceMinter(&_MinterRole.TransactOpts)
  4761  }
  4762  
  4763  // MinterRoleMinterAddedIterator is returned from FilterMinterAdded and is used to iterate over the raw logs and unpacked data for MinterAdded events raised by the MinterRole contract.
  4764  type MinterRoleMinterAddedIterator struct {
  4765  	Event *MinterRoleMinterAdded // Event containing the contract specifics and raw log
  4766  
  4767  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  4768  	event    string              // Event name to use for unpacking event data
  4769  
  4770  	logs chan types.Log        // Log channel receiving the found contract events
  4771  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  4772  	done bool                  // Whether the subscription completed delivering logs
  4773  	fail error                 // Occurred error to stop iteration
  4774  }
  4775  
  4776  // Next advances the iterator to the subsequent event, returning whether there
  4777  // are any more events found. In case of a retrieval or parsing error, false is
  4778  // returned and Error() can be queried for the exact failure.
  4779  func (it *MinterRoleMinterAddedIterator) Next() bool {
  4780  	// If the iterator failed, stop iterating
  4781  	if it.fail != nil {
  4782  		return false
  4783  	}
  4784  	// If the iterator completed, deliver directly whatever's available
  4785  	if it.done {
  4786  		select {
  4787  		case log := <-it.logs:
  4788  			it.Event = new(MinterRoleMinterAdded)
  4789  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4790  				it.fail = err
  4791  				return false
  4792  			}
  4793  			it.Event.Raw = log
  4794  			return true
  4795  
  4796  		default:
  4797  			return false
  4798  		}
  4799  	}
  4800  	// Iterator still in progress, wait for either a data or an error event
  4801  	select {
  4802  	case log := <-it.logs:
  4803  		it.Event = new(MinterRoleMinterAdded)
  4804  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4805  			it.fail = err
  4806  			return false
  4807  		}
  4808  		it.Event.Raw = log
  4809  		return true
  4810  
  4811  	case err := <-it.sub.Err():
  4812  		it.done = true
  4813  		it.fail = err
  4814  		return it.Next()
  4815  	}
  4816  }
  4817  
  4818  // Error returns any retrieval or parsing error occurred during filtering.
  4819  func (it *MinterRoleMinterAddedIterator) Error() error {
  4820  	return it.fail
  4821  }
  4822  
  4823  // Close terminates the iteration process, releasing any pending underlying
  4824  // resources.
  4825  func (it *MinterRoleMinterAddedIterator) Close() error {
  4826  	it.sub.Unsubscribe()
  4827  	return nil
  4828  }
  4829  
  4830  // MinterRoleMinterAdded represents a MinterAdded event raised by the MinterRole contract.
  4831  type MinterRoleMinterAdded struct {
  4832  	Account common.Address
  4833  	Raw     types.Log // Blockchain specific contextual infos
  4834  }
  4835  
  4836  // FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
  4837  //
  4838  // Solidity: event MinterAdded(address indexed account)
  4839  func (_MinterRole *MinterRoleFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*MinterRoleMinterAddedIterator, error) {
  4840  
  4841  	var accountRule []interface{}
  4842  	for _, accountItem := range account {
  4843  		accountRule = append(accountRule, accountItem)
  4844  	}
  4845  
  4846  	logs, sub, err := _MinterRole.contract.FilterLogs(opts, "MinterAdded", accountRule)
  4847  	if err != nil {
  4848  		return nil, err
  4849  	}
  4850  	return &MinterRoleMinterAddedIterator{contract: _MinterRole.contract, event: "MinterAdded", logs: logs, sub: sub}, nil
  4851  }
  4852  
  4853  // WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
  4854  //
  4855  // Solidity: event MinterAdded(address indexed account)
  4856  func (_MinterRole *MinterRoleFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *MinterRoleMinterAdded, account []common.Address) (event.Subscription, error) {
  4857  
  4858  	var accountRule []interface{}
  4859  	for _, accountItem := range account {
  4860  		accountRule = append(accountRule, accountItem)
  4861  	}
  4862  
  4863  	logs, sub, err := _MinterRole.contract.WatchLogs(opts, "MinterAdded", accountRule)
  4864  	if err != nil {
  4865  		return nil, err
  4866  	}
  4867  	return event.NewSubscription(func(quit <-chan struct{}) error {
  4868  		defer sub.Unsubscribe()
  4869  		for {
  4870  			select {
  4871  			case log := <-logs:
  4872  				// New log arrived, parse the event and forward to the user
  4873  				event := new(MinterRoleMinterAdded)
  4874  				if err := _MinterRole.contract.UnpackLog(event, "MinterAdded", log); err != nil {
  4875  					return err
  4876  				}
  4877  				event.Raw = log
  4878  
  4879  				select {
  4880  				case sink <- event:
  4881  				case err := <-sub.Err():
  4882  					return err
  4883  				case <-quit:
  4884  					return nil
  4885  				}
  4886  			case err := <-sub.Err():
  4887  				return err
  4888  			case <-quit:
  4889  				return nil
  4890  			}
  4891  		}
  4892  	}), nil
  4893  }
  4894  
  4895  // ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
  4896  //
  4897  // Solidity: event MinterAdded(address indexed account)
  4898  func (_MinterRole *MinterRoleFilterer) ParseMinterAdded(log types.Log) (*MinterRoleMinterAdded, error) {
  4899  	event := new(MinterRoleMinterAdded)
  4900  	if err := _MinterRole.contract.UnpackLog(event, "MinterAdded", log); err != nil {
  4901  		return nil, err
  4902  	}
  4903  	return event, nil
  4904  }
  4905  
  4906  // MinterRoleMinterRemovedIterator is returned from FilterMinterRemoved and is used to iterate over the raw logs and unpacked data for MinterRemoved events raised by the MinterRole contract.
  4907  type MinterRoleMinterRemovedIterator struct {
  4908  	Event *MinterRoleMinterRemoved // Event containing the contract specifics and raw log
  4909  
  4910  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  4911  	event    string              // Event name to use for unpacking event data
  4912  
  4913  	logs chan types.Log        // Log channel receiving the found contract events
  4914  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  4915  	done bool                  // Whether the subscription completed delivering logs
  4916  	fail error                 // Occurred error to stop iteration
  4917  }
  4918  
  4919  // Next advances the iterator to the subsequent event, returning whether there
  4920  // are any more events found. In case of a retrieval or parsing error, false is
  4921  // returned and Error() can be queried for the exact failure.
  4922  func (it *MinterRoleMinterRemovedIterator) Next() bool {
  4923  	// If the iterator failed, stop iterating
  4924  	if it.fail != nil {
  4925  		return false
  4926  	}
  4927  	// If the iterator completed, deliver directly whatever's available
  4928  	if it.done {
  4929  		select {
  4930  		case log := <-it.logs:
  4931  			it.Event = new(MinterRoleMinterRemoved)
  4932  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4933  				it.fail = err
  4934  				return false
  4935  			}
  4936  			it.Event.Raw = log
  4937  			return true
  4938  
  4939  		default:
  4940  			return false
  4941  		}
  4942  	}
  4943  	// Iterator still in progress, wait for either a data or an error event
  4944  	select {
  4945  	case log := <-it.logs:
  4946  		it.Event = new(MinterRoleMinterRemoved)
  4947  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4948  			it.fail = err
  4949  			return false
  4950  		}
  4951  		it.Event.Raw = log
  4952  		return true
  4953  
  4954  	case err := <-it.sub.Err():
  4955  		it.done = true
  4956  		it.fail = err
  4957  		return it.Next()
  4958  	}
  4959  }
  4960  
  4961  // Error returns any retrieval or parsing error occurred during filtering.
  4962  func (it *MinterRoleMinterRemovedIterator) Error() error {
  4963  	return it.fail
  4964  }
  4965  
  4966  // Close terminates the iteration process, releasing any pending underlying
  4967  // resources.
  4968  func (it *MinterRoleMinterRemovedIterator) Close() error {
  4969  	it.sub.Unsubscribe()
  4970  	return nil
  4971  }
  4972  
  4973  // MinterRoleMinterRemoved represents a MinterRemoved event raised by the MinterRole contract.
  4974  type MinterRoleMinterRemoved struct {
  4975  	Account common.Address
  4976  	Raw     types.Log // Blockchain specific contextual infos
  4977  }
  4978  
  4979  // FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
  4980  //
  4981  // Solidity: event MinterRemoved(address indexed account)
  4982  func (_MinterRole *MinterRoleFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*MinterRoleMinterRemovedIterator, error) {
  4983  
  4984  	var accountRule []interface{}
  4985  	for _, accountItem := range account {
  4986  		accountRule = append(accountRule, accountItem)
  4987  	}
  4988  
  4989  	logs, sub, err := _MinterRole.contract.FilterLogs(opts, "MinterRemoved", accountRule)
  4990  	if err != nil {
  4991  		return nil, err
  4992  	}
  4993  	return &MinterRoleMinterRemovedIterator{contract: _MinterRole.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil
  4994  }
  4995  
  4996  // WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
  4997  //
  4998  // Solidity: event MinterRemoved(address indexed account)
  4999  func (_MinterRole *MinterRoleFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *MinterRoleMinterRemoved, account []common.Address) (event.Subscription, error) {
  5000  
  5001  	var accountRule []interface{}
  5002  	for _, accountItem := range account {
  5003  		accountRule = append(accountRule, accountItem)
  5004  	}
  5005  
  5006  	logs, sub, err := _MinterRole.contract.WatchLogs(opts, "MinterRemoved", accountRule)
  5007  	if err != nil {
  5008  		return nil, err
  5009  	}
  5010  	return event.NewSubscription(func(quit <-chan struct{}) error {
  5011  		defer sub.Unsubscribe()
  5012  		for {
  5013  			select {
  5014  			case log := <-logs:
  5015  				// New log arrived, parse the event and forward to the user
  5016  				event := new(MinterRoleMinterRemoved)
  5017  				if err := _MinterRole.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
  5018  					return err
  5019  				}
  5020  				event.Raw = log
  5021  
  5022  				select {
  5023  				case sink <- event:
  5024  				case err := <-sub.Err():
  5025  					return err
  5026  				case <-quit:
  5027  					return nil
  5028  				}
  5029  			case err := <-sub.Err():
  5030  				return err
  5031  			case <-quit:
  5032  				return nil
  5033  			}
  5034  		}
  5035  	}), nil
  5036  }
  5037  
  5038  // ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
  5039  //
  5040  // Solidity: event MinterRemoved(address indexed account)
  5041  func (_MinterRole *MinterRoleFilterer) ParseMinterRemoved(log types.Log) (*MinterRoleMinterRemoved, error) {
  5042  	event := new(MinterRoleMinterRemoved)
  5043  	if err := _MinterRole.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
  5044  		return nil, err
  5045  	}
  5046  	return event, nil
  5047  }
  5048  
  5049  // MinterRoleRenounceTargetABI is the input ABI used to generate the binding from.
  5050  const MinterRoleRenounceTargetABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
  5051  
  5052  // MinterRoleRenounceTargetFuncSigs maps the 4-byte function signature to its string representation.
  5053  var MinterRoleRenounceTargetFuncSigs = map[string]string{
  5054  	"98650275": "renounceMinter()",
  5055  }
  5056  
  5057  // MinterRoleRenounceTarget is an auto generated Go binding around an Ethereum contract.
  5058  type MinterRoleRenounceTarget struct {
  5059  	MinterRoleRenounceTargetCaller     // Read-only binding to the contract
  5060  	MinterRoleRenounceTargetTransactor // Write-only binding to the contract
  5061  	MinterRoleRenounceTargetFilterer   // Log filterer for contract events
  5062  }
  5063  
  5064  // MinterRoleRenounceTargetCaller is an auto generated read-only Go binding around an Ethereum contract.
  5065  type MinterRoleRenounceTargetCaller struct {
  5066  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5067  }
  5068  
  5069  // MinterRoleRenounceTargetTransactor is an auto generated write-only Go binding around an Ethereum contract.
  5070  type MinterRoleRenounceTargetTransactor struct {
  5071  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5072  }
  5073  
  5074  // MinterRoleRenounceTargetFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  5075  type MinterRoleRenounceTargetFilterer struct {
  5076  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5077  }
  5078  
  5079  // MinterRoleRenounceTargetSession is an auto generated Go binding around an Ethereum contract,
  5080  // with pre-set call and transact options.
  5081  type MinterRoleRenounceTargetSession struct {
  5082  	Contract     *MinterRoleRenounceTarget // Generic contract binding to set the session for
  5083  	CallOpts     bind.CallOpts             // Call options to use throughout this session
  5084  	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
  5085  }
  5086  
  5087  // MinterRoleRenounceTargetCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  5088  // with pre-set call options.
  5089  type MinterRoleRenounceTargetCallerSession struct {
  5090  	Contract *MinterRoleRenounceTargetCaller // Generic contract caller binding to set the session for
  5091  	CallOpts bind.CallOpts                   // Call options to use throughout this session
  5092  }
  5093  
  5094  // MinterRoleRenounceTargetTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  5095  // with pre-set transact options.
  5096  type MinterRoleRenounceTargetTransactorSession struct {
  5097  	Contract     *MinterRoleRenounceTargetTransactor // Generic contract transactor binding to set the session for
  5098  	TransactOpts bind.TransactOpts                   // Transaction auth options to use throughout this session
  5099  }
  5100  
  5101  // MinterRoleRenounceTargetRaw is an auto generated low-level Go binding around an Ethereum contract.
  5102  type MinterRoleRenounceTargetRaw struct {
  5103  	Contract *MinterRoleRenounceTarget // Generic contract binding to access the raw methods on
  5104  }
  5105  
  5106  // MinterRoleRenounceTargetCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  5107  type MinterRoleRenounceTargetCallerRaw struct {
  5108  	Contract *MinterRoleRenounceTargetCaller // Generic read-only contract binding to access the raw methods on
  5109  }
  5110  
  5111  // MinterRoleRenounceTargetTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  5112  type MinterRoleRenounceTargetTransactorRaw struct {
  5113  	Contract *MinterRoleRenounceTargetTransactor // Generic write-only contract binding to access the raw methods on
  5114  }
  5115  
  5116  // NewMinterRoleRenounceTarget creates a new instance of MinterRoleRenounceTarget, bound to a specific deployed contract.
  5117  func NewMinterRoleRenounceTarget(address common.Address, backend bind.ContractBackend) (*MinterRoleRenounceTarget, error) {
  5118  	contract, err := bindMinterRoleRenounceTarget(address, backend, backend, backend)
  5119  	if err != nil {
  5120  		return nil, err
  5121  	}
  5122  	return &MinterRoleRenounceTarget{MinterRoleRenounceTargetCaller: MinterRoleRenounceTargetCaller{contract: contract}, MinterRoleRenounceTargetTransactor: MinterRoleRenounceTargetTransactor{contract: contract}, MinterRoleRenounceTargetFilterer: MinterRoleRenounceTargetFilterer{contract: contract}}, nil
  5123  }
  5124  
  5125  // NewMinterRoleRenounceTargetCaller creates a new read-only instance of MinterRoleRenounceTarget, bound to a specific deployed contract.
  5126  func NewMinterRoleRenounceTargetCaller(address common.Address, caller bind.ContractCaller) (*MinterRoleRenounceTargetCaller, error) {
  5127  	contract, err := bindMinterRoleRenounceTarget(address, caller, nil, nil)
  5128  	if err != nil {
  5129  		return nil, err
  5130  	}
  5131  	return &MinterRoleRenounceTargetCaller{contract: contract}, nil
  5132  }
  5133  
  5134  // NewMinterRoleRenounceTargetTransactor creates a new write-only instance of MinterRoleRenounceTarget, bound to a specific deployed contract.
  5135  func NewMinterRoleRenounceTargetTransactor(address common.Address, transactor bind.ContractTransactor) (*MinterRoleRenounceTargetTransactor, error) {
  5136  	contract, err := bindMinterRoleRenounceTarget(address, nil, transactor, nil)
  5137  	if err != nil {
  5138  		return nil, err
  5139  	}
  5140  	return &MinterRoleRenounceTargetTransactor{contract: contract}, nil
  5141  }
  5142  
  5143  // NewMinterRoleRenounceTargetFilterer creates a new log filterer instance of MinterRoleRenounceTarget, bound to a specific deployed contract.
  5144  func NewMinterRoleRenounceTargetFilterer(address common.Address, filterer bind.ContractFilterer) (*MinterRoleRenounceTargetFilterer, error) {
  5145  	contract, err := bindMinterRoleRenounceTarget(address, nil, nil, filterer)
  5146  	if err != nil {
  5147  		return nil, err
  5148  	}
  5149  	return &MinterRoleRenounceTargetFilterer{contract: contract}, nil
  5150  }
  5151  
  5152  // bindMinterRoleRenounceTarget binds a generic wrapper to an already deployed contract.
  5153  func bindMinterRoleRenounceTarget(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  5154  	parsed, err := abi.JSON(strings.NewReader(MinterRoleRenounceTargetABI))
  5155  	if err != nil {
  5156  		return nil, err
  5157  	}
  5158  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  5159  }
  5160  
  5161  // Call invokes the (constant) contract method with params as input values and
  5162  // sets the output to result. The result type might be a single field for simple
  5163  // returns, a slice of interfaces for anonymous returns and a struct for named
  5164  // returns.
  5165  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  5166  	return _MinterRoleRenounceTarget.Contract.MinterRoleRenounceTargetCaller.contract.Call(opts, result, method, params...)
  5167  }
  5168  
  5169  // Transfer initiates a plain transaction to move funds to the contract, calling
  5170  // its default method if one is available.
  5171  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  5172  	return _MinterRoleRenounceTarget.Contract.MinterRoleRenounceTargetTransactor.contract.Transfer(opts)
  5173  }
  5174  
  5175  // Transact invokes the (paid) contract method with params as input values.
  5176  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  5177  	return _MinterRoleRenounceTarget.Contract.MinterRoleRenounceTargetTransactor.contract.Transact(opts, method, params...)
  5178  }
  5179  
  5180  // Call invokes the (constant) contract method with params as input values and
  5181  // sets the output to result. The result type might be a single field for simple
  5182  // returns, a slice of interfaces for anonymous returns and a struct for named
  5183  // returns.
  5184  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  5185  	return _MinterRoleRenounceTarget.Contract.contract.Call(opts, result, method, params...)
  5186  }
  5187  
  5188  // Transfer initiates a plain transaction to move funds to the contract, calling
  5189  // its default method if one is available.
  5190  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  5191  	return _MinterRoleRenounceTarget.Contract.contract.Transfer(opts)
  5192  }
  5193  
  5194  // Transact invokes the (paid) contract method with params as input values.
  5195  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  5196  	return _MinterRoleRenounceTarget.Contract.contract.Transact(opts, method, params...)
  5197  }
  5198  
  5199  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  5200  //
  5201  // Solidity: function renounceMinter() returns()
  5202  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) {
  5203  	return _MinterRoleRenounceTarget.contract.Transact(opts, "renounceMinter")
  5204  }
  5205  
  5206  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  5207  //
  5208  // Solidity: function renounceMinter() returns()
  5209  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetSession) RenounceMinter() (*types.Transaction, error) {
  5210  	return _MinterRoleRenounceTarget.Contract.RenounceMinter(&_MinterRoleRenounceTarget.TransactOpts)
  5211  }
  5212  
  5213  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  5214  //
  5215  // Solidity: function renounceMinter() returns()
  5216  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactorSession) RenounceMinter() (*types.Transaction, error) {
  5217  	return _MinterRoleRenounceTarget.Contract.RenounceMinter(&_MinterRoleRenounceTarget.TransactOpts)
  5218  }
  5219  
  5220  // OnApproveConstantABI is the input ABI used to generate the binding from.
  5221  const OnApproveConstantABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"INTERFACE_ID_ON_APPROVE\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"
  5222  
  5223  // OnApproveConstantFuncSigs maps the 4-byte function signature to its string representation.
  5224  var OnApproveConstantFuncSigs = map[string]string{
  5225  	"6cd28f9a": "INTERFACE_ID_ON_APPROVE()",
  5226  }
  5227  
  5228  // OnApproveConstantBin is the compiled bytecode used for deploying new contracts.
  5229  var OnApproveConstantBin = "0x6080604052348015600f57600080fd5b5060c78061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c80636cd28f9a14602d575b600080fd5b60336050565b604080516001600160e01b03199092168252519081900360200190f35b604051806028606b8239602801905060405180910390208156fe6f6e417070726f766528616464726573732c616464726573732c75696e743235362c627974657329a265627a7a723158206d94182e39f46cad6425154650e56ecd40259e07a64364bd131e67fe91c85c7664736f6c634300050c0032"
  5230  
  5231  // DeployOnApproveConstant deploys a new Ethereum contract, binding an instance of OnApproveConstant to it.
  5232  func DeployOnApproveConstant(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *OnApproveConstant, error) {
  5233  	parsed, err := abi.JSON(strings.NewReader(OnApproveConstantABI))
  5234  	if err != nil {
  5235  		return common.Address{}, nil, nil, err
  5236  	}
  5237  
  5238  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(OnApproveConstantBin), backend)
  5239  	if err != nil {
  5240  		return common.Address{}, nil, nil, err
  5241  	}
  5242  	return address, tx, &OnApproveConstant{OnApproveConstantCaller: OnApproveConstantCaller{contract: contract}, OnApproveConstantTransactor: OnApproveConstantTransactor{contract: contract}, OnApproveConstantFilterer: OnApproveConstantFilterer{contract: contract}}, nil
  5243  }
  5244  
  5245  // OnApproveConstant is an auto generated Go binding around an Ethereum contract.
  5246  type OnApproveConstant struct {
  5247  	OnApproveConstantCaller     // Read-only binding to the contract
  5248  	OnApproveConstantTransactor // Write-only binding to the contract
  5249  	OnApproveConstantFilterer   // Log filterer for contract events
  5250  }
  5251  
  5252  // OnApproveConstantCaller is an auto generated read-only Go binding around an Ethereum contract.
  5253  type OnApproveConstantCaller struct {
  5254  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5255  }
  5256  
  5257  // OnApproveConstantTransactor is an auto generated write-only Go binding around an Ethereum contract.
  5258  type OnApproveConstantTransactor struct {
  5259  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5260  }
  5261  
  5262  // OnApproveConstantFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  5263  type OnApproveConstantFilterer struct {
  5264  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5265  }
  5266  
  5267  // OnApproveConstantSession is an auto generated Go binding around an Ethereum contract,
  5268  // with pre-set call and transact options.
  5269  type OnApproveConstantSession struct {
  5270  	Contract     *OnApproveConstant // Generic contract binding to set the session for
  5271  	CallOpts     bind.CallOpts      // Call options to use throughout this session
  5272  	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
  5273  }
  5274  
  5275  // OnApproveConstantCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  5276  // with pre-set call options.
  5277  type OnApproveConstantCallerSession struct {
  5278  	Contract *OnApproveConstantCaller // Generic contract caller binding to set the session for
  5279  	CallOpts bind.CallOpts            // Call options to use throughout this session
  5280  }
  5281  
  5282  // OnApproveConstantTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  5283  // with pre-set transact options.
  5284  type OnApproveConstantTransactorSession struct {
  5285  	Contract     *OnApproveConstantTransactor // Generic contract transactor binding to set the session for
  5286  	TransactOpts bind.TransactOpts            // Transaction auth options to use throughout this session
  5287  }
  5288  
  5289  // OnApproveConstantRaw is an auto generated low-level Go binding around an Ethereum contract.
  5290  type OnApproveConstantRaw struct {
  5291  	Contract *OnApproveConstant // Generic contract binding to access the raw methods on
  5292  }
  5293  
  5294  // OnApproveConstantCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  5295  type OnApproveConstantCallerRaw struct {
  5296  	Contract *OnApproveConstantCaller // Generic read-only contract binding to access the raw methods on
  5297  }
  5298  
  5299  // OnApproveConstantTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  5300  type OnApproveConstantTransactorRaw struct {
  5301  	Contract *OnApproveConstantTransactor // Generic write-only contract binding to access the raw methods on
  5302  }
  5303  
  5304  // NewOnApproveConstant creates a new instance of OnApproveConstant, bound to a specific deployed contract.
  5305  func NewOnApproveConstant(address common.Address, backend bind.ContractBackend) (*OnApproveConstant, error) {
  5306  	contract, err := bindOnApproveConstant(address, backend, backend, backend)
  5307  	if err != nil {
  5308  		return nil, err
  5309  	}
  5310  	return &OnApproveConstant{OnApproveConstantCaller: OnApproveConstantCaller{contract: contract}, OnApproveConstantTransactor: OnApproveConstantTransactor{contract: contract}, OnApproveConstantFilterer: OnApproveConstantFilterer{contract: contract}}, nil
  5311  }
  5312  
  5313  // NewOnApproveConstantCaller creates a new read-only instance of OnApproveConstant, bound to a specific deployed contract.
  5314  func NewOnApproveConstantCaller(address common.Address, caller bind.ContractCaller) (*OnApproveConstantCaller, error) {
  5315  	contract, err := bindOnApproveConstant(address, caller, nil, nil)
  5316  	if err != nil {
  5317  		return nil, err
  5318  	}
  5319  	return &OnApproveConstantCaller{contract: contract}, nil
  5320  }
  5321  
  5322  // NewOnApproveConstantTransactor creates a new write-only instance of OnApproveConstant, bound to a specific deployed contract.
  5323  func NewOnApproveConstantTransactor(address common.Address, transactor bind.ContractTransactor) (*OnApproveConstantTransactor, error) {
  5324  	contract, err := bindOnApproveConstant(address, nil, transactor, nil)
  5325  	if err != nil {
  5326  		return nil, err
  5327  	}
  5328  	return &OnApproveConstantTransactor{contract: contract}, nil
  5329  }
  5330  
  5331  // NewOnApproveConstantFilterer creates a new log filterer instance of OnApproveConstant, bound to a specific deployed contract.
  5332  func NewOnApproveConstantFilterer(address common.Address, filterer bind.ContractFilterer) (*OnApproveConstantFilterer, error) {
  5333  	contract, err := bindOnApproveConstant(address, nil, nil, filterer)
  5334  	if err != nil {
  5335  		return nil, err
  5336  	}
  5337  	return &OnApproveConstantFilterer{contract: contract}, nil
  5338  }
  5339  
  5340  // bindOnApproveConstant binds a generic wrapper to an already deployed contract.
  5341  func bindOnApproveConstant(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  5342  	parsed, err := abi.JSON(strings.NewReader(OnApproveConstantABI))
  5343  	if err != nil {
  5344  		return nil, err
  5345  	}
  5346  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  5347  }
  5348  
  5349  // Call invokes the (constant) contract method with params as input values and
  5350  // sets the output to result. The result type might be a single field for simple
  5351  // returns, a slice of interfaces for anonymous returns and a struct for named
  5352  // returns.
  5353  func (_OnApproveConstant *OnApproveConstantRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  5354  	return _OnApproveConstant.Contract.OnApproveConstantCaller.contract.Call(opts, result, method, params...)
  5355  }
  5356  
  5357  // Transfer initiates a plain transaction to move funds to the contract, calling
  5358  // its default method if one is available.
  5359  func (_OnApproveConstant *OnApproveConstantRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  5360  	return _OnApproveConstant.Contract.OnApproveConstantTransactor.contract.Transfer(opts)
  5361  }
  5362  
  5363  // Transact invokes the (paid) contract method with params as input values.
  5364  func (_OnApproveConstant *OnApproveConstantRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  5365  	return _OnApproveConstant.Contract.OnApproveConstantTransactor.contract.Transact(opts, method, params...)
  5366  }
  5367  
  5368  // Call invokes the (constant) contract method with params as input values and
  5369  // sets the output to result. The result type might be a single field for simple
  5370  // returns, a slice of interfaces for anonymous returns and a struct for named
  5371  // returns.
  5372  func (_OnApproveConstant *OnApproveConstantCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  5373  	return _OnApproveConstant.Contract.contract.Call(opts, result, method, params...)
  5374  }
  5375  
  5376  // Transfer initiates a plain transaction to move funds to the contract, calling
  5377  // its default method if one is available.
  5378  func (_OnApproveConstant *OnApproveConstantTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  5379  	return _OnApproveConstant.Contract.contract.Transfer(opts)
  5380  }
  5381  
  5382  // Transact invokes the (paid) contract method with params as input values.
  5383  func (_OnApproveConstant *OnApproveConstantTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  5384  	return _OnApproveConstant.Contract.contract.Transact(opts, method, params...)
  5385  }
  5386  
  5387  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  5388  //
  5389  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  5390  func (_OnApproveConstant *OnApproveConstantCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) {
  5391  	var (
  5392  		ret0 = new([4]byte)
  5393  	)
  5394  	out := ret0
  5395  	err := _OnApproveConstant.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE")
  5396  	return *ret0, err
  5397  }
  5398  
  5399  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  5400  //
  5401  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  5402  func (_OnApproveConstant *OnApproveConstantSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  5403  	return _OnApproveConstant.Contract.INTERFACEIDONAPPROVE(&_OnApproveConstant.CallOpts)
  5404  }
  5405  
  5406  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  5407  //
  5408  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  5409  func (_OnApproveConstant *OnApproveConstantCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  5410  	return _OnApproveConstant.Contract.INTERFACEIDONAPPROVE(&_OnApproveConstant.CallOpts)
  5411  }
  5412  
  5413  // OwnableABI is the input ABI used to generate the binding from.
  5414  const OwnableABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
  5415  
  5416  // OwnableFuncSigs maps the 4-byte function signature to its string representation.
  5417  var OwnableFuncSigs = map[string]string{
  5418  	"8f32d59b": "isOwner()",
  5419  	"8da5cb5b": "owner()",
  5420  	"715018a6": "renounceOwnership()",
  5421  	"f2fde38b": "transferOwnership(address)",
  5422  }
  5423  
  5424  // Ownable is an auto generated Go binding around an Ethereum contract.
  5425  type Ownable struct {
  5426  	OwnableCaller     // Read-only binding to the contract
  5427  	OwnableTransactor // Write-only binding to the contract
  5428  	OwnableFilterer   // Log filterer for contract events
  5429  }
  5430  
  5431  // OwnableCaller is an auto generated read-only Go binding around an Ethereum contract.
  5432  type OwnableCaller struct {
  5433  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5434  }
  5435  
  5436  // OwnableTransactor is an auto generated write-only Go binding around an Ethereum contract.
  5437  type OwnableTransactor struct {
  5438  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5439  }
  5440  
  5441  // OwnableFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  5442  type OwnableFilterer struct {
  5443  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5444  }
  5445  
  5446  // OwnableSession is an auto generated Go binding around an Ethereum contract,
  5447  // with pre-set call and transact options.
  5448  type OwnableSession struct {
  5449  	Contract     *Ownable          // Generic contract binding to set the session for
  5450  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  5451  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  5452  }
  5453  
  5454  // OwnableCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  5455  // with pre-set call options.
  5456  type OwnableCallerSession struct {
  5457  	Contract *OwnableCaller // Generic contract caller binding to set the session for
  5458  	CallOpts bind.CallOpts  // Call options to use throughout this session
  5459  }
  5460  
  5461  // OwnableTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  5462  // with pre-set transact options.
  5463  type OwnableTransactorSession struct {
  5464  	Contract     *OwnableTransactor // Generic contract transactor binding to set the session for
  5465  	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
  5466  }
  5467  
  5468  // OwnableRaw is an auto generated low-level Go binding around an Ethereum contract.
  5469  type OwnableRaw struct {
  5470  	Contract *Ownable // Generic contract binding to access the raw methods on
  5471  }
  5472  
  5473  // OwnableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  5474  type OwnableCallerRaw struct {
  5475  	Contract *OwnableCaller // Generic read-only contract binding to access the raw methods on
  5476  }
  5477  
  5478  // OwnableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  5479  type OwnableTransactorRaw struct {
  5480  	Contract *OwnableTransactor // Generic write-only contract binding to access the raw methods on
  5481  }
  5482  
  5483  // NewOwnable creates a new instance of Ownable, bound to a specific deployed contract.
  5484  func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error) {
  5485  	contract, err := bindOwnable(address, backend, backend, backend)
  5486  	if err != nil {
  5487  		return nil, err
  5488  	}
  5489  	return &Ownable{OwnableCaller: OwnableCaller{contract: contract}, OwnableTransactor: OwnableTransactor{contract: contract}, OwnableFilterer: OwnableFilterer{contract: contract}}, nil
  5490  }
  5491  
  5492  // NewOwnableCaller creates a new read-only instance of Ownable, bound to a specific deployed contract.
  5493  func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error) {
  5494  	contract, err := bindOwnable(address, caller, nil, nil)
  5495  	if err != nil {
  5496  		return nil, err
  5497  	}
  5498  	return &OwnableCaller{contract: contract}, nil
  5499  }
  5500  
  5501  // NewOwnableTransactor creates a new write-only instance of Ownable, bound to a specific deployed contract.
  5502  func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error) {
  5503  	contract, err := bindOwnable(address, nil, transactor, nil)
  5504  	if err != nil {
  5505  		return nil, err
  5506  	}
  5507  	return &OwnableTransactor{contract: contract}, nil
  5508  }
  5509  
  5510  // NewOwnableFilterer creates a new log filterer instance of Ownable, bound to a specific deployed contract.
  5511  func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error) {
  5512  	contract, err := bindOwnable(address, nil, nil, filterer)
  5513  	if err != nil {
  5514  		return nil, err
  5515  	}
  5516  	return &OwnableFilterer{contract: contract}, nil
  5517  }
  5518  
  5519  // bindOwnable binds a generic wrapper to an already deployed contract.
  5520  func bindOwnable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  5521  	parsed, err := abi.JSON(strings.NewReader(OwnableABI))
  5522  	if err != nil {
  5523  		return nil, err
  5524  	}
  5525  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  5526  }
  5527  
  5528  // Call invokes the (constant) contract method with params as input values and
  5529  // sets the output to result. The result type might be a single field for simple
  5530  // returns, a slice of interfaces for anonymous returns and a struct for named
  5531  // returns.
  5532  func (_Ownable *OwnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  5533  	return _Ownable.Contract.OwnableCaller.contract.Call(opts, result, method, params...)
  5534  }
  5535  
  5536  // Transfer initiates a plain transaction to move funds to the contract, calling
  5537  // its default method if one is available.
  5538  func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  5539  	return _Ownable.Contract.OwnableTransactor.contract.Transfer(opts)
  5540  }
  5541  
  5542  // Transact invokes the (paid) contract method with params as input values.
  5543  func (_Ownable *OwnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  5544  	return _Ownable.Contract.OwnableTransactor.contract.Transact(opts, method, params...)
  5545  }
  5546  
  5547  // Call invokes the (constant) contract method with params as input values and
  5548  // sets the output to result. The result type might be a single field for simple
  5549  // returns, a slice of interfaces for anonymous returns and a struct for named
  5550  // returns.
  5551  func (_Ownable *OwnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  5552  	return _Ownable.Contract.contract.Call(opts, result, method, params...)
  5553  }
  5554  
  5555  // Transfer initiates a plain transaction to move funds to the contract, calling
  5556  // its default method if one is available.
  5557  func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  5558  	return _Ownable.Contract.contract.Transfer(opts)
  5559  }
  5560  
  5561  // Transact invokes the (paid) contract method with params as input values.
  5562  func (_Ownable *OwnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  5563  	return _Ownable.Contract.contract.Transact(opts, method, params...)
  5564  }
  5565  
  5566  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
  5567  //
  5568  // Solidity: function isOwner() constant returns(bool)
  5569  func (_Ownable *OwnableCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
  5570  	var (
  5571  		ret0 = new(bool)
  5572  	)
  5573  	out := ret0
  5574  	err := _Ownable.contract.Call(opts, out, "isOwner")
  5575  	return *ret0, err
  5576  }
  5577  
  5578  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
  5579  //
  5580  // Solidity: function isOwner() constant returns(bool)
  5581  func (_Ownable *OwnableSession) IsOwner() (bool, error) {
  5582  	return _Ownable.Contract.IsOwner(&_Ownable.CallOpts)
  5583  }
  5584  
  5585  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
  5586  //
  5587  // Solidity: function isOwner() constant returns(bool)
  5588  func (_Ownable *OwnableCallerSession) IsOwner() (bool, error) {
  5589  	return _Ownable.Contract.IsOwner(&_Ownable.CallOpts)
  5590  }
  5591  
  5592  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  5593  //
  5594  // Solidity: function owner() constant returns(address)
  5595  func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
  5596  	var (
  5597  		ret0 = new(common.Address)
  5598  	)
  5599  	out := ret0
  5600  	err := _Ownable.contract.Call(opts, out, "owner")
  5601  	return *ret0, err
  5602  }
  5603  
  5604  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  5605  //
  5606  // Solidity: function owner() constant returns(address)
  5607  func (_Ownable *OwnableSession) Owner() (common.Address, error) {
  5608  	return _Ownable.Contract.Owner(&_Ownable.CallOpts)
  5609  }
  5610  
  5611  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  5612  //
  5613  // Solidity: function owner() constant returns(address)
  5614  func (_Ownable *OwnableCallerSession) Owner() (common.Address, error) {
  5615  	return _Ownable.Contract.Owner(&_Ownable.CallOpts)
  5616  }
  5617  
  5618  // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
  5619  //
  5620  // Solidity: function renounceOwnership() returns()
  5621  func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
  5622  	return _Ownable.contract.Transact(opts, "renounceOwnership")
  5623  }
  5624  
  5625  // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
  5626  //
  5627  // Solidity: function renounceOwnership() returns()
  5628  func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, error) {
  5629  	return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts)
  5630  }
  5631  
  5632  // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
  5633  //
  5634  // Solidity: function renounceOwnership() returns()
  5635  func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, error) {
  5636  	return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts)
  5637  }
  5638  
  5639  // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
  5640  //
  5641  // Solidity: function transferOwnership(address newOwner) returns()
  5642  func (_Ownable *OwnableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
  5643  	return _Ownable.contract.Transact(opts, "transferOwnership", newOwner)
  5644  }
  5645  
  5646  // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
  5647  //
  5648  // Solidity: function transferOwnership(address newOwner) returns()
  5649  func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
  5650  	return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner)
  5651  }
  5652  
  5653  // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
  5654  //
  5655  // Solidity: function transferOwnership(address newOwner) returns()
  5656  func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
  5657  	return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner)
  5658  }
  5659  
  5660  // OwnableOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Ownable contract.
  5661  type OwnableOwnershipTransferredIterator struct {
  5662  	Event *OwnableOwnershipTransferred // Event containing the contract specifics and raw log
  5663  
  5664  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  5665  	event    string              // Event name to use for unpacking event data
  5666  
  5667  	logs chan types.Log        // Log channel receiving the found contract events
  5668  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  5669  	done bool                  // Whether the subscription completed delivering logs
  5670  	fail error                 // Occurred error to stop iteration
  5671  }
  5672  
  5673  // Next advances the iterator to the subsequent event, returning whether there
  5674  // are any more events found. In case of a retrieval or parsing error, false is
  5675  // returned and Error() can be queried for the exact failure.
  5676  func (it *OwnableOwnershipTransferredIterator) Next() bool {
  5677  	// If the iterator failed, stop iterating
  5678  	if it.fail != nil {
  5679  		return false
  5680  	}
  5681  	// If the iterator completed, deliver directly whatever's available
  5682  	if it.done {
  5683  		select {
  5684  		case log := <-it.logs:
  5685  			it.Event = new(OwnableOwnershipTransferred)
  5686  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  5687  				it.fail = err
  5688  				return false
  5689  			}
  5690  			it.Event.Raw = log
  5691  			return true
  5692  
  5693  		default:
  5694  			return false
  5695  		}
  5696  	}
  5697  	// Iterator still in progress, wait for either a data or an error event
  5698  	select {
  5699  	case log := <-it.logs:
  5700  		it.Event = new(OwnableOwnershipTransferred)
  5701  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  5702  			it.fail = err
  5703  			return false
  5704  		}
  5705  		it.Event.Raw = log
  5706  		return true
  5707  
  5708  	case err := <-it.sub.Err():
  5709  		it.done = true
  5710  		it.fail = err
  5711  		return it.Next()
  5712  	}
  5713  }
  5714  
  5715  // Error returns any retrieval or parsing error occurred during filtering.
  5716  func (it *OwnableOwnershipTransferredIterator) Error() error {
  5717  	return it.fail
  5718  }
  5719  
  5720  // Close terminates the iteration process, releasing any pending underlying
  5721  // resources.
  5722  func (it *OwnableOwnershipTransferredIterator) Close() error {
  5723  	it.sub.Unsubscribe()
  5724  	return nil
  5725  }
  5726  
  5727  // OwnableOwnershipTransferred represents a OwnershipTransferred event raised by the Ownable contract.
  5728  type OwnableOwnershipTransferred struct {
  5729  	PreviousOwner common.Address
  5730  	NewOwner      common.Address
  5731  	Raw           types.Log // Blockchain specific contextual infos
  5732  }
  5733  
  5734  // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
  5735  //
  5736  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
  5737  func (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*OwnableOwnershipTransferredIterator, error) {
  5738  
  5739  	var previousOwnerRule []interface{}
  5740  	for _, previousOwnerItem := range previousOwner {
  5741  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
  5742  	}
  5743  	var newOwnerRule []interface{}
  5744  	for _, newOwnerItem := range newOwner {
  5745  		newOwnerRule = append(newOwnerRule, newOwnerItem)
  5746  	}
  5747  
  5748  	logs, sub, err := _Ownable.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
  5749  	if err != nil {
  5750  		return nil, err
  5751  	}
  5752  	return &OwnableOwnershipTransferredIterator{contract: _Ownable.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
  5753  }
  5754  
  5755  // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
  5756  //
  5757  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
  5758  func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {
  5759  
  5760  	var previousOwnerRule []interface{}
  5761  	for _, previousOwnerItem := range previousOwner {
  5762  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
  5763  	}
  5764  	var newOwnerRule []interface{}
  5765  	for _, newOwnerItem := range newOwner {
  5766  		newOwnerRule = append(newOwnerRule, newOwnerItem)
  5767  	}
  5768  
  5769  	logs, sub, err := _Ownable.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
  5770  	if err != nil {
  5771  		return nil, err
  5772  	}
  5773  	return event.NewSubscription(func(quit <-chan struct{}) error {
  5774  		defer sub.Unsubscribe()
  5775  		for {
  5776  			select {
  5777  			case log := <-logs:
  5778  				// New log arrived, parse the event and forward to the user
  5779  				event := new(OwnableOwnershipTransferred)
  5780  				if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
  5781  					return err
  5782  				}
  5783  				event.Raw = log
  5784  
  5785  				select {
  5786  				case sink <- event:
  5787  				case err := <-sub.Err():
  5788  					return err
  5789  				case <-quit:
  5790  					return nil
  5791  				}
  5792  			case err := <-sub.Err():
  5793  				return err
  5794  			case <-quit:
  5795  				return nil
  5796  			}
  5797  		}
  5798  	}), nil
  5799  }
  5800  
  5801  // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
  5802  //
  5803  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
  5804  func (_Ownable *OwnableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnableOwnershipTransferred, error) {
  5805  	event := new(OwnableOwnershipTransferred)
  5806  	if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
  5807  		return nil, err
  5808  	}
  5809  	return event, nil
  5810  }
  5811  
  5812  // OwnableTargetABI is the input ABI used to generate the binding from.
  5813  const OwnableTargetABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
  5814  
  5815  // OwnableTargetFuncSigs maps the 4-byte function signature to its string representation.
  5816  var OwnableTargetFuncSigs = map[string]string{
  5817  	"715018a6": "renounceOwnership()",
  5818  	"f2fde38b": "transferOwnership(address)",
  5819  }
  5820  
  5821  // OwnableTarget is an auto generated Go binding around an Ethereum contract.
  5822  type OwnableTarget struct {
  5823  	OwnableTargetCaller     // Read-only binding to the contract
  5824  	OwnableTargetTransactor // Write-only binding to the contract
  5825  	OwnableTargetFilterer   // Log filterer for contract events
  5826  }
  5827  
  5828  // OwnableTargetCaller is an auto generated read-only Go binding around an Ethereum contract.
  5829  type OwnableTargetCaller struct {
  5830  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5831  }
  5832  
  5833  // OwnableTargetTransactor is an auto generated write-only Go binding around an Ethereum contract.
  5834  type OwnableTargetTransactor struct {
  5835  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5836  }
  5837  
  5838  // OwnableTargetFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  5839  type OwnableTargetFilterer struct {
  5840  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5841  }
  5842  
  5843  // OwnableTargetSession is an auto generated Go binding around an Ethereum contract,
  5844  // with pre-set call and transact options.
  5845  type OwnableTargetSession struct {
  5846  	Contract     *OwnableTarget    // Generic contract binding to set the session for
  5847  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  5848  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  5849  }
  5850  
  5851  // OwnableTargetCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  5852  // with pre-set call options.
  5853  type OwnableTargetCallerSession struct {
  5854  	Contract *OwnableTargetCaller // Generic contract caller binding to set the session for
  5855  	CallOpts bind.CallOpts        // Call options to use throughout this session
  5856  }
  5857  
  5858  // OwnableTargetTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  5859  // with pre-set transact options.
  5860  type OwnableTargetTransactorSession struct {
  5861  	Contract     *OwnableTargetTransactor // Generic contract transactor binding to set the session for
  5862  	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
  5863  }
  5864  
  5865  // OwnableTargetRaw is an auto generated low-level Go binding around an Ethereum contract.
  5866  type OwnableTargetRaw struct {
  5867  	Contract *OwnableTarget // Generic contract binding to access the raw methods on
  5868  }
  5869  
  5870  // OwnableTargetCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  5871  type OwnableTargetCallerRaw struct {
  5872  	Contract *OwnableTargetCaller // Generic read-only contract binding to access the raw methods on
  5873  }
  5874  
  5875  // OwnableTargetTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  5876  type OwnableTargetTransactorRaw struct {
  5877  	Contract *OwnableTargetTransactor // Generic write-only contract binding to access the raw methods on
  5878  }
  5879  
  5880  // NewOwnableTarget creates a new instance of OwnableTarget, bound to a specific deployed contract.
  5881  func NewOwnableTarget(address common.Address, backend bind.ContractBackend) (*OwnableTarget, error) {
  5882  	contract, err := bindOwnableTarget(address, backend, backend, backend)
  5883  	if err != nil {
  5884  		return nil, err
  5885  	}
  5886  	return &OwnableTarget{OwnableTargetCaller: OwnableTargetCaller{contract: contract}, OwnableTargetTransactor: OwnableTargetTransactor{contract: contract}, OwnableTargetFilterer: OwnableTargetFilterer{contract: contract}}, nil
  5887  }
  5888  
  5889  // NewOwnableTargetCaller creates a new read-only instance of OwnableTarget, bound to a specific deployed contract.
  5890  func NewOwnableTargetCaller(address common.Address, caller bind.ContractCaller) (*OwnableTargetCaller, error) {
  5891  	contract, err := bindOwnableTarget(address, caller, nil, nil)
  5892  	if err != nil {
  5893  		return nil, err
  5894  	}
  5895  	return &OwnableTargetCaller{contract: contract}, nil
  5896  }
  5897  
  5898  // NewOwnableTargetTransactor creates a new write-only instance of OwnableTarget, bound to a specific deployed contract.
  5899  func NewOwnableTargetTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTargetTransactor, error) {
  5900  	contract, err := bindOwnableTarget(address, nil, transactor, nil)
  5901  	if err != nil {
  5902  		return nil, err
  5903  	}
  5904  	return &OwnableTargetTransactor{contract: contract}, nil
  5905  }
  5906  
  5907  // NewOwnableTargetFilterer creates a new log filterer instance of OwnableTarget, bound to a specific deployed contract.
  5908  func NewOwnableTargetFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableTargetFilterer, error) {
  5909  	contract, err := bindOwnableTarget(address, nil, nil, filterer)
  5910  	if err != nil {
  5911  		return nil, err
  5912  	}
  5913  	return &OwnableTargetFilterer{contract: contract}, nil
  5914  }
  5915  
  5916  // bindOwnableTarget binds a generic wrapper to an already deployed contract.
  5917  func bindOwnableTarget(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  5918  	parsed, err := abi.JSON(strings.NewReader(OwnableTargetABI))
  5919  	if err != nil {
  5920  		return nil, err
  5921  	}
  5922  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  5923  }
  5924  
  5925  // Call invokes the (constant) contract method with params as input values and
  5926  // sets the output to result. The result type might be a single field for simple
  5927  // returns, a slice of interfaces for anonymous returns and a struct for named
  5928  // returns.
  5929  func (_OwnableTarget *OwnableTargetRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  5930  	return _OwnableTarget.Contract.OwnableTargetCaller.contract.Call(opts, result, method, params...)
  5931  }
  5932  
  5933  // Transfer initiates a plain transaction to move funds to the contract, calling
  5934  // its default method if one is available.
  5935  func (_OwnableTarget *OwnableTargetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  5936  	return _OwnableTarget.Contract.OwnableTargetTransactor.contract.Transfer(opts)
  5937  }
  5938  
  5939  // Transact invokes the (paid) contract method with params as input values.
  5940  func (_OwnableTarget *OwnableTargetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  5941  	return _OwnableTarget.Contract.OwnableTargetTransactor.contract.Transact(opts, method, params...)
  5942  }
  5943  
  5944  // Call invokes the (constant) contract method with params as input values and
  5945  // sets the output to result. The result type might be a single field for simple
  5946  // returns, a slice of interfaces for anonymous returns and a struct for named
  5947  // returns.
  5948  func (_OwnableTarget *OwnableTargetCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  5949  	return _OwnableTarget.Contract.contract.Call(opts, result, method, params...)
  5950  }
  5951  
  5952  // Transfer initiates a plain transaction to move funds to the contract, calling
  5953  // its default method if one is available.
  5954  func (_OwnableTarget *OwnableTargetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  5955  	return _OwnableTarget.Contract.contract.Transfer(opts)
  5956  }
  5957  
  5958  // Transact invokes the (paid) contract method with params as input values.
  5959  func (_OwnableTarget *OwnableTargetTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  5960  	return _OwnableTarget.Contract.contract.Transact(opts, method, params...)
  5961  }
  5962  
  5963  // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
  5964  //
  5965  // Solidity: function renounceOwnership() returns()
  5966  func (_OwnableTarget *OwnableTargetTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
  5967  	return _OwnableTarget.contract.Transact(opts, "renounceOwnership")
  5968  }
  5969  
  5970  // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
  5971  //
  5972  // Solidity: function renounceOwnership() returns()
  5973  func (_OwnableTarget *OwnableTargetSession) RenounceOwnership() (*types.Transaction, error) {
  5974  	return _OwnableTarget.Contract.RenounceOwnership(&_OwnableTarget.TransactOpts)
  5975  }
  5976  
  5977  // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
  5978  //
  5979  // Solidity: function renounceOwnership() returns()
  5980  func (_OwnableTarget *OwnableTargetTransactorSession) RenounceOwnership() (*types.Transaction, error) {
  5981  	return _OwnableTarget.Contract.RenounceOwnership(&_OwnableTarget.TransactOpts)
  5982  }
  5983  
  5984  // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
  5985  //
  5986  // Solidity: function transferOwnership(address newOwner) returns()
  5987  func (_OwnableTarget *OwnableTargetTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
  5988  	return _OwnableTarget.contract.Transact(opts, "transferOwnership", newOwner)
  5989  }
  5990  
  5991  // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
  5992  //
  5993  // Solidity: function transferOwnership(address newOwner) returns()
  5994  func (_OwnableTarget *OwnableTargetSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
  5995  	return _OwnableTarget.Contract.TransferOwnership(&_OwnableTarget.TransactOpts, newOwner)
  5996  }
  5997  
  5998  // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
  5999  //
  6000  // Solidity: function transferOwnership(address newOwner) returns()
  6001  func (_OwnableTarget *OwnableTargetTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
  6002  	return _OwnableTarget.Contract.TransferOwnership(&_OwnableTarget.TransactOpts, newOwner)
  6003  }
  6004  
  6005  // PauserRoleRenounceTargetABI is the input ABI used to generate the binding from.
  6006  const PauserRoleRenounceTargetABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
  6007  
  6008  // PauserRoleRenounceTargetFuncSigs maps the 4-byte function signature to its string representation.
  6009  var PauserRoleRenounceTargetFuncSigs = map[string]string{
  6010  	"6ef8d66d": "renouncePauser()",
  6011  }
  6012  
  6013  // PauserRoleRenounceTarget is an auto generated Go binding around an Ethereum contract.
  6014  type PauserRoleRenounceTarget struct {
  6015  	PauserRoleRenounceTargetCaller     // Read-only binding to the contract
  6016  	PauserRoleRenounceTargetTransactor // Write-only binding to the contract
  6017  	PauserRoleRenounceTargetFilterer   // Log filterer for contract events
  6018  }
  6019  
  6020  // PauserRoleRenounceTargetCaller is an auto generated read-only Go binding around an Ethereum contract.
  6021  type PauserRoleRenounceTargetCaller struct {
  6022  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  6023  }
  6024  
  6025  // PauserRoleRenounceTargetTransactor is an auto generated write-only Go binding around an Ethereum contract.
  6026  type PauserRoleRenounceTargetTransactor struct {
  6027  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  6028  }
  6029  
  6030  // PauserRoleRenounceTargetFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  6031  type PauserRoleRenounceTargetFilterer struct {
  6032  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  6033  }
  6034  
  6035  // PauserRoleRenounceTargetSession is an auto generated Go binding around an Ethereum contract,
  6036  // with pre-set call and transact options.
  6037  type PauserRoleRenounceTargetSession struct {
  6038  	Contract     *PauserRoleRenounceTarget // Generic contract binding to set the session for
  6039  	CallOpts     bind.CallOpts             // Call options to use throughout this session
  6040  	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
  6041  }
  6042  
  6043  // PauserRoleRenounceTargetCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  6044  // with pre-set call options.
  6045  type PauserRoleRenounceTargetCallerSession struct {
  6046  	Contract *PauserRoleRenounceTargetCaller // Generic contract caller binding to set the session for
  6047  	CallOpts bind.CallOpts                   // Call options to use throughout this session
  6048  }
  6049  
  6050  // PauserRoleRenounceTargetTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  6051  // with pre-set transact options.
  6052  type PauserRoleRenounceTargetTransactorSession struct {
  6053  	Contract     *PauserRoleRenounceTargetTransactor // Generic contract transactor binding to set the session for
  6054  	TransactOpts bind.TransactOpts                   // Transaction auth options to use throughout this session
  6055  }
  6056  
  6057  // PauserRoleRenounceTargetRaw is an auto generated low-level Go binding around an Ethereum contract.
  6058  type PauserRoleRenounceTargetRaw struct {
  6059  	Contract *PauserRoleRenounceTarget // Generic contract binding to access the raw methods on
  6060  }
  6061  
  6062  // PauserRoleRenounceTargetCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  6063  type PauserRoleRenounceTargetCallerRaw struct {
  6064  	Contract *PauserRoleRenounceTargetCaller // Generic read-only contract binding to access the raw methods on
  6065  }
  6066  
  6067  // PauserRoleRenounceTargetTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  6068  type PauserRoleRenounceTargetTransactorRaw struct {
  6069  	Contract *PauserRoleRenounceTargetTransactor // Generic write-only contract binding to access the raw methods on
  6070  }
  6071  
  6072  // NewPauserRoleRenounceTarget creates a new instance of PauserRoleRenounceTarget, bound to a specific deployed contract.
  6073  func NewPauserRoleRenounceTarget(address common.Address, backend bind.ContractBackend) (*PauserRoleRenounceTarget, error) {
  6074  	contract, err := bindPauserRoleRenounceTarget(address, backend, backend, backend)
  6075  	if err != nil {
  6076  		return nil, err
  6077  	}
  6078  	return &PauserRoleRenounceTarget{PauserRoleRenounceTargetCaller: PauserRoleRenounceTargetCaller{contract: contract}, PauserRoleRenounceTargetTransactor: PauserRoleRenounceTargetTransactor{contract: contract}, PauserRoleRenounceTargetFilterer: PauserRoleRenounceTargetFilterer{contract: contract}}, nil
  6079  }
  6080  
  6081  // NewPauserRoleRenounceTargetCaller creates a new read-only instance of PauserRoleRenounceTarget, bound to a specific deployed contract.
  6082  func NewPauserRoleRenounceTargetCaller(address common.Address, caller bind.ContractCaller) (*PauserRoleRenounceTargetCaller, error) {
  6083  	contract, err := bindPauserRoleRenounceTarget(address, caller, nil, nil)
  6084  	if err != nil {
  6085  		return nil, err
  6086  	}
  6087  	return &PauserRoleRenounceTargetCaller{contract: contract}, nil
  6088  }
  6089  
  6090  // NewPauserRoleRenounceTargetTransactor creates a new write-only instance of PauserRoleRenounceTarget, bound to a specific deployed contract.
  6091  func NewPauserRoleRenounceTargetTransactor(address common.Address, transactor bind.ContractTransactor) (*PauserRoleRenounceTargetTransactor, error) {
  6092  	contract, err := bindPauserRoleRenounceTarget(address, nil, transactor, nil)
  6093  	if err != nil {
  6094  		return nil, err
  6095  	}
  6096  	return &PauserRoleRenounceTargetTransactor{contract: contract}, nil
  6097  }
  6098  
  6099  // NewPauserRoleRenounceTargetFilterer creates a new log filterer instance of PauserRoleRenounceTarget, bound to a specific deployed contract.
  6100  func NewPauserRoleRenounceTargetFilterer(address common.Address, filterer bind.ContractFilterer) (*PauserRoleRenounceTargetFilterer, error) {
  6101  	contract, err := bindPauserRoleRenounceTarget(address, nil, nil, filterer)
  6102  	if err != nil {
  6103  		return nil, err
  6104  	}
  6105  	return &PauserRoleRenounceTargetFilterer{contract: contract}, nil
  6106  }
  6107  
  6108  // bindPauserRoleRenounceTarget binds a generic wrapper to an already deployed contract.
  6109  func bindPauserRoleRenounceTarget(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  6110  	parsed, err := abi.JSON(strings.NewReader(PauserRoleRenounceTargetABI))
  6111  	if err != nil {
  6112  		return nil, err
  6113  	}
  6114  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  6115  }
  6116  
  6117  // Call invokes the (constant) contract method with params as input values and
  6118  // sets the output to result. The result type might be a single field for simple
  6119  // returns, a slice of interfaces for anonymous returns and a struct for named
  6120  // returns.
  6121  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  6122  	return _PauserRoleRenounceTarget.Contract.PauserRoleRenounceTargetCaller.contract.Call(opts, result, method, params...)
  6123  }
  6124  
  6125  // Transfer initiates a plain transaction to move funds to the contract, calling
  6126  // its default method if one is available.
  6127  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  6128  	return _PauserRoleRenounceTarget.Contract.PauserRoleRenounceTargetTransactor.contract.Transfer(opts)
  6129  }
  6130  
  6131  // Transact invokes the (paid) contract method with params as input values.
  6132  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  6133  	return _PauserRoleRenounceTarget.Contract.PauserRoleRenounceTargetTransactor.contract.Transact(opts, method, params...)
  6134  }
  6135  
  6136  // Call invokes the (constant) contract method with params as input values and
  6137  // sets the output to result. The result type might be a single field for simple
  6138  // returns, a slice of interfaces for anonymous returns and a struct for named
  6139  // returns.
  6140  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  6141  	return _PauserRoleRenounceTarget.Contract.contract.Call(opts, result, method, params...)
  6142  }
  6143  
  6144  // Transfer initiates a plain transaction to move funds to the contract, calling
  6145  // its default method if one is available.
  6146  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  6147  	return _PauserRoleRenounceTarget.Contract.contract.Transfer(opts)
  6148  }
  6149  
  6150  // Transact invokes the (paid) contract method with params as input values.
  6151  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  6152  	return _PauserRoleRenounceTarget.Contract.contract.Transact(opts, method, params...)
  6153  }
  6154  
  6155  // RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
  6156  //
  6157  // Solidity: function renouncePauser() returns()
  6158  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactor) RenouncePauser(opts *bind.TransactOpts) (*types.Transaction, error) {
  6159  	return _PauserRoleRenounceTarget.contract.Transact(opts, "renouncePauser")
  6160  }
  6161  
  6162  // RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
  6163  //
  6164  // Solidity: function renouncePauser() returns()
  6165  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetSession) RenouncePauser() (*types.Transaction, error) {
  6166  	return _PauserRoleRenounceTarget.Contract.RenouncePauser(&_PauserRoleRenounceTarget.TransactOpts)
  6167  }
  6168  
  6169  // RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
  6170  //
  6171  // Solidity: function renouncePauser() returns()
  6172  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactorSession) RenouncePauser() (*types.Transaction, error) {
  6173  	return _PauserRoleRenounceTarget.Contract.RenouncePauser(&_PauserRoleRenounceTarget.TransactOpts)
  6174  }
  6175  
  6176  // RolesABI is the input ABI used to generate the binding from.
  6177  const RolesABI = "[]"
  6178  
  6179  // RolesBin is the compiled bytecode used for deploying new contracts.
  6180  var RolesBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a72315820451a2112c879141f72bbe0ec00d853511a9d98646af7e3081d90a3d70270eb1564736f6c634300050c0032"
  6181  
  6182  // DeployRoles deploys a new Ethereum contract, binding an instance of Roles to it.
  6183  func DeployRoles(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Roles, error) {
  6184  	parsed, err := abi.JSON(strings.NewReader(RolesABI))
  6185  	if err != nil {
  6186  		return common.Address{}, nil, nil, err
  6187  	}
  6188  
  6189  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(RolesBin), backend)
  6190  	if err != nil {
  6191  		return common.Address{}, nil, nil, err
  6192  	}
  6193  	return address, tx, &Roles{RolesCaller: RolesCaller{contract: contract}, RolesTransactor: RolesTransactor{contract: contract}, RolesFilterer: RolesFilterer{contract: contract}}, nil
  6194  }
  6195  
  6196  // Roles is an auto generated Go binding around an Ethereum contract.
  6197  type Roles struct {
  6198  	RolesCaller     // Read-only binding to the contract
  6199  	RolesTransactor // Write-only binding to the contract
  6200  	RolesFilterer   // Log filterer for contract events
  6201  }
  6202  
  6203  // RolesCaller is an auto generated read-only Go binding around an Ethereum contract.
  6204  type RolesCaller struct {
  6205  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  6206  }
  6207  
  6208  // RolesTransactor is an auto generated write-only Go binding around an Ethereum contract.
  6209  type RolesTransactor struct {
  6210  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  6211  }
  6212  
  6213  // RolesFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  6214  type RolesFilterer struct {
  6215  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  6216  }
  6217  
  6218  // RolesSession is an auto generated Go binding around an Ethereum contract,
  6219  // with pre-set call and transact options.
  6220  type RolesSession struct {
  6221  	Contract     *Roles            // Generic contract binding to set the session for
  6222  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  6223  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  6224  }
  6225  
  6226  // RolesCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  6227  // with pre-set call options.
  6228  type RolesCallerSession struct {
  6229  	Contract *RolesCaller  // Generic contract caller binding to set the session for
  6230  	CallOpts bind.CallOpts // Call options to use throughout this session
  6231  }
  6232  
  6233  // RolesTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  6234  // with pre-set transact options.
  6235  type RolesTransactorSession struct {
  6236  	Contract     *RolesTransactor  // Generic contract transactor binding to set the session for
  6237  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  6238  }
  6239  
  6240  // RolesRaw is an auto generated low-level Go binding around an Ethereum contract.
  6241  type RolesRaw struct {
  6242  	Contract *Roles // Generic contract binding to access the raw methods on
  6243  }
  6244  
  6245  // RolesCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  6246  type RolesCallerRaw struct {
  6247  	Contract *RolesCaller // Generic read-only contract binding to access the raw methods on
  6248  }
  6249  
  6250  // RolesTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  6251  type RolesTransactorRaw struct {
  6252  	Contract *RolesTransactor // Generic write-only contract binding to access the raw methods on
  6253  }
  6254  
  6255  // NewRoles creates a new instance of Roles, bound to a specific deployed contract.
  6256  func NewRoles(address common.Address, backend bind.ContractBackend) (*Roles, error) {
  6257  	contract, err := bindRoles(address, backend, backend, backend)
  6258  	if err != nil {
  6259  		return nil, err
  6260  	}
  6261  	return &Roles{RolesCaller: RolesCaller{contract: contract}, RolesTransactor: RolesTransactor{contract: contract}, RolesFilterer: RolesFilterer{contract: contract}}, nil
  6262  }
  6263  
  6264  // NewRolesCaller creates a new read-only instance of Roles, bound to a specific deployed contract.
  6265  func NewRolesCaller(address common.Address, caller bind.ContractCaller) (*RolesCaller, error) {
  6266  	contract, err := bindRoles(address, caller, nil, nil)
  6267  	if err != nil {
  6268  		return nil, err
  6269  	}
  6270  	return &RolesCaller{contract: contract}, nil
  6271  }
  6272  
  6273  // NewRolesTransactor creates a new write-only instance of Roles, bound to a specific deployed contract.
  6274  func NewRolesTransactor(address common.Address, transactor bind.ContractTransactor) (*RolesTransactor, error) {
  6275  	contract, err := bindRoles(address, nil, transactor, nil)
  6276  	if err != nil {
  6277  		return nil, err
  6278  	}
  6279  	return &RolesTransactor{contract: contract}, nil
  6280  }
  6281  
  6282  // NewRolesFilterer creates a new log filterer instance of Roles, bound to a specific deployed contract.
  6283  func NewRolesFilterer(address common.Address, filterer bind.ContractFilterer) (*RolesFilterer, error) {
  6284  	contract, err := bindRoles(address, nil, nil, filterer)
  6285  	if err != nil {
  6286  		return nil, err
  6287  	}
  6288  	return &RolesFilterer{contract: contract}, nil
  6289  }
  6290  
  6291  // bindRoles binds a generic wrapper to an already deployed contract.
  6292  func bindRoles(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  6293  	parsed, err := abi.JSON(strings.NewReader(RolesABI))
  6294  	if err != nil {
  6295  		return nil, err
  6296  	}
  6297  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  6298  }
  6299  
  6300  // Call invokes the (constant) contract method with params as input values and
  6301  // sets the output to result. The result type might be a single field for simple
  6302  // returns, a slice of interfaces for anonymous returns and a struct for named
  6303  // returns.
  6304  func (_Roles *RolesRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  6305  	return _Roles.Contract.RolesCaller.contract.Call(opts, result, method, params...)
  6306  }
  6307  
  6308  // Transfer initiates a plain transaction to move funds to the contract, calling
  6309  // its default method if one is available.
  6310  func (_Roles *RolesRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  6311  	return _Roles.Contract.RolesTransactor.contract.Transfer(opts)
  6312  }
  6313  
  6314  // Transact invokes the (paid) contract method with params as input values.
  6315  func (_Roles *RolesRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  6316  	return _Roles.Contract.RolesTransactor.contract.Transact(opts, method, params...)
  6317  }
  6318  
  6319  // Call invokes the (constant) contract method with params as input values and
  6320  // sets the output to result. The result type might be a single field for simple
  6321  // returns, a slice of interfaces for anonymous returns and a struct for named
  6322  // returns.
  6323  func (_Roles *RolesCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  6324  	return _Roles.Contract.contract.Call(opts, result, method, params...)
  6325  }
  6326  
  6327  // Transfer initiates a plain transaction to move funds to the contract, calling
  6328  // its default method if one is available.
  6329  func (_Roles *RolesTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  6330  	return _Roles.Contract.contract.Transfer(opts)
  6331  }
  6332  
  6333  // Transact invokes the (paid) contract method with params as input values.
  6334  func (_Roles *RolesTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  6335  	return _Roles.Contract.contract.Transact(opts, method, params...)
  6336  }
  6337  
  6338  // SafeMathABI is the input ABI used to generate the binding from.
  6339  const SafeMathABI = "[]"
  6340  
  6341  // SafeMathBin is the compiled bytecode used for deploying new contracts.
  6342  var SafeMathBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582045f810ccb41cd151344ccf006ddfbe7c3c58a867d26e345c6576ae09178171dc64736f6c634300050c0032"
  6343  
  6344  // DeploySafeMath deploys a new Ethereum contract, binding an instance of SafeMath to it.
  6345  func DeploySafeMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeMath, error) {
  6346  	parsed, err := abi.JSON(strings.NewReader(SafeMathABI))
  6347  	if err != nil {
  6348  		return common.Address{}, nil, nil, err
  6349  	}
  6350  
  6351  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SafeMathBin), backend)
  6352  	if err != nil {
  6353  		return common.Address{}, nil, nil, err
  6354  	}
  6355  	return address, tx, &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil
  6356  }
  6357  
  6358  // SafeMath is an auto generated Go binding around an Ethereum contract.
  6359  type SafeMath struct {
  6360  	SafeMathCaller     // Read-only binding to the contract
  6361  	SafeMathTransactor // Write-only binding to the contract
  6362  	SafeMathFilterer   // Log filterer for contract events
  6363  }
  6364  
  6365  // SafeMathCaller is an auto generated read-only Go binding around an Ethereum contract.
  6366  type SafeMathCaller struct {
  6367  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  6368  }
  6369  
  6370  // SafeMathTransactor is an auto generated write-only Go binding around an Ethereum contract.
  6371  type SafeMathTransactor struct {
  6372  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  6373  }
  6374  
  6375  // SafeMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  6376  type SafeMathFilterer struct {
  6377  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  6378  }
  6379  
  6380  // SafeMathSession is an auto generated Go binding around an Ethereum contract,
  6381  // with pre-set call and transact options.
  6382  type SafeMathSession struct {
  6383  	Contract     *SafeMath         // Generic contract binding to set the session for
  6384  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  6385  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  6386  }
  6387  
  6388  // SafeMathCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  6389  // with pre-set call options.
  6390  type SafeMathCallerSession struct {
  6391  	Contract *SafeMathCaller // Generic contract caller binding to set the session for
  6392  	CallOpts bind.CallOpts   // Call options to use throughout this session
  6393  }
  6394  
  6395  // SafeMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  6396  // with pre-set transact options.
  6397  type SafeMathTransactorSession struct {
  6398  	Contract     *SafeMathTransactor // Generic contract transactor binding to set the session for
  6399  	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
  6400  }
  6401  
  6402  // SafeMathRaw is an auto generated low-level Go binding around an Ethereum contract.
  6403  type SafeMathRaw struct {
  6404  	Contract *SafeMath // Generic contract binding to access the raw methods on
  6405  }
  6406  
  6407  // SafeMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  6408  type SafeMathCallerRaw struct {
  6409  	Contract *SafeMathCaller // Generic read-only contract binding to access the raw methods on
  6410  }
  6411  
  6412  // SafeMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  6413  type SafeMathTransactorRaw struct {
  6414  	Contract *SafeMathTransactor // Generic write-only contract binding to access the raw methods on
  6415  }
  6416  
  6417  // NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract.
  6418  func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error) {
  6419  	contract, err := bindSafeMath(address, backend, backend, backend)
  6420  	if err != nil {
  6421  		return nil, err
  6422  	}
  6423  	return &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil
  6424  }
  6425  
  6426  // NewSafeMathCaller creates a new read-only instance of SafeMath, bound to a specific deployed contract.
  6427  func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error) {
  6428  	contract, err := bindSafeMath(address, caller, nil, nil)
  6429  	if err != nil {
  6430  		return nil, err
  6431  	}
  6432  	return &SafeMathCaller{contract: contract}, nil
  6433  }
  6434  
  6435  // NewSafeMathTransactor creates a new write-only instance of SafeMath, bound to a specific deployed contract.
  6436  func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error) {
  6437  	contract, err := bindSafeMath(address, nil, transactor, nil)
  6438  	if err != nil {
  6439  		return nil, err
  6440  	}
  6441  	return &SafeMathTransactor{contract: contract}, nil
  6442  }
  6443  
  6444  // NewSafeMathFilterer creates a new log filterer instance of SafeMath, bound to a specific deployed contract.
  6445  func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error) {
  6446  	contract, err := bindSafeMath(address, nil, nil, filterer)
  6447  	if err != nil {
  6448  		return nil, err
  6449  	}
  6450  	return &SafeMathFilterer{contract: contract}, nil
  6451  }
  6452  
  6453  // bindSafeMath binds a generic wrapper to an already deployed contract.
  6454  func bindSafeMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  6455  	parsed, err := abi.JSON(strings.NewReader(SafeMathABI))
  6456  	if err != nil {
  6457  		return nil, err
  6458  	}
  6459  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  6460  }
  6461  
  6462  // Call invokes the (constant) contract method with params as input values and
  6463  // sets the output to result. The result type might be a single field for simple
  6464  // returns, a slice of interfaces for anonymous returns and a struct for named
  6465  // returns.
  6466  func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  6467  	return _SafeMath.Contract.SafeMathCaller.contract.Call(opts, result, method, params...)
  6468  }
  6469  
  6470  // Transfer initiates a plain transaction to move funds to the contract, calling
  6471  // its default method if one is available.
  6472  func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  6473  	return _SafeMath.Contract.SafeMathTransactor.contract.Transfer(opts)
  6474  }
  6475  
  6476  // Transact invokes the (paid) contract method with params as input values.
  6477  func (_SafeMath *SafeMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  6478  	return _SafeMath.Contract.SafeMathTransactor.contract.Transact(opts, method, params...)
  6479  }
  6480  
  6481  // Call invokes the (constant) contract method with params as input values and
  6482  // sets the output to result. The result type might be a single field for simple
  6483  // returns, a slice of interfaces for anonymous returns and a struct for named
  6484  // returns.
  6485  func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  6486  	return _SafeMath.Contract.contract.Call(opts, result, method, params...)
  6487  }
  6488  
  6489  // Transfer initiates a plain transaction to move funds to the contract, calling
  6490  // its default method if one is available.
  6491  func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  6492  	return _SafeMath.Contract.contract.Transfer(opts)
  6493  }
  6494  
  6495  // Transact invokes the (paid) contract method with params as input values.
  6496  func (_SafeMath *SafeMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  6497  	return _SafeMath.Contract.contract.Transact(opts, method, params...)
  6498  }
  6499  
  6500  // SeigManagerIABI is the input ABI used to generate the binding from.
  6501  const SeigManagerIABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"DEFAULT_FACTOR\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"additionalTotBurnAmount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"totAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"coinages\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"commissionRates\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"deployCoinage\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"depositManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"lastCommitBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"lastSeigBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"onCommit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"onDeposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"onTransfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"onWithdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"pausedBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"powerton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigPerBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"commission\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"isCommissionRateNegative\",\"type\":\"bool\"}],\"name\":\"setCommissionRate\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"stakeOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"ton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"tot\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"uncomittedStakeOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"unpausedBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"wton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"
  6502  
  6503  // SeigManagerIFuncSigs maps the 4-byte function signature to its string representation.
  6504  var SeigManagerIFuncSigs = map[string]string{
  6505  	"8bf91dc4": "DEFAULT_FACTOR()",
  6506  	"48c8577e": "additionalTotBurnAmount(address,address,uint256)",
  6507  	"4c063c19": "coinages(address)",
  6508  	"7b056c1b": "commissionRates(address)",
  6509  	"833a774f": "deployCoinage(address)",
  6510  	"6c7ac9d8": "depositManager()",
  6511  	"c59f1046": "lastCommitBlock(address)",
  6512  	"f35c89e8": "lastSeigBlock()",
  6513  	"359c4d59": "onCommit()",
  6514  	"412c6d50": "onDeposit(address,address,uint256)",
  6515  	"4a393149": "onTransfer(address,address,uint256)",
  6516  	"f850ffaa": "onWithdraw(address,address,uint256)",
  6517  	"32053c99": "pausedBlock()",
  6518  	"3e832e1d": "powerton()",
  6519  	"7b103999": "registry()",
  6520  	"5f40a349": "seigPerBlock()",
  6521  	"4224ed66": "setCommissionRate(address,uint256,bool)",
  6522  	"ce4cb876": "stakeOf(address,address)",
  6523  	"cc48b947": "ton()",
  6524  	"a16d6aa7": "tot()",
  6525  	"fa9789c8": "uncomittedStakeOf(address,address)",
  6526  	"1cc47890": "unpausedBlock()",
  6527  	"8d62d949": "wton()",
  6528  }
  6529  
  6530  // SeigManagerI is an auto generated Go binding around an Ethereum contract.
  6531  type SeigManagerI struct {
  6532  	SeigManagerICaller     // Read-only binding to the contract
  6533  	SeigManagerITransactor // Write-only binding to the contract
  6534  	SeigManagerIFilterer   // Log filterer for contract events
  6535  }
  6536  
  6537  // SeigManagerICaller is an auto generated read-only Go binding around an Ethereum contract.
  6538  type SeigManagerICaller struct {
  6539  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  6540  }
  6541  
  6542  // SeigManagerITransactor is an auto generated write-only Go binding around an Ethereum contract.
  6543  type SeigManagerITransactor struct {
  6544  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  6545  }
  6546  
  6547  // SeigManagerIFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  6548  type SeigManagerIFilterer struct {
  6549  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  6550  }
  6551  
  6552  // SeigManagerISession is an auto generated Go binding around an Ethereum contract,
  6553  // with pre-set call and transact options.
  6554  type SeigManagerISession struct {
  6555  	Contract     *SeigManagerI     // Generic contract binding to set the session for
  6556  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  6557  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  6558  }
  6559  
  6560  // SeigManagerICallerSession is an auto generated read-only Go binding around an Ethereum contract,
  6561  // with pre-set call options.
  6562  type SeigManagerICallerSession struct {
  6563  	Contract *SeigManagerICaller // Generic contract caller binding to set the session for
  6564  	CallOpts bind.CallOpts       // Call options to use throughout this session
  6565  }
  6566  
  6567  // SeigManagerITransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  6568  // with pre-set transact options.
  6569  type SeigManagerITransactorSession struct {
  6570  	Contract     *SeigManagerITransactor // Generic contract transactor binding to set the session for
  6571  	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
  6572  }
  6573  
  6574  // SeigManagerIRaw is an auto generated low-level Go binding around an Ethereum contract.
  6575  type SeigManagerIRaw struct {
  6576  	Contract *SeigManagerI // Generic contract binding to access the raw methods on
  6577  }
  6578  
  6579  // SeigManagerICallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  6580  type SeigManagerICallerRaw struct {
  6581  	Contract *SeigManagerICaller // Generic read-only contract binding to access the raw methods on
  6582  }
  6583  
  6584  // SeigManagerITransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  6585  type SeigManagerITransactorRaw struct {
  6586  	Contract *SeigManagerITransactor // Generic write-only contract binding to access the raw methods on
  6587  }
  6588  
  6589  // NewSeigManagerI creates a new instance of SeigManagerI, bound to a specific deployed contract.
  6590  func NewSeigManagerI(address common.Address, backend bind.ContractBackend) (*SeigManagerI, error) {
  6591  	contract, err := bindSeigManagerI(address, backend, backend, backend)
  6592  	if err != nil {
  6593  		return nil, err
  6594  	}
  6595  	return &SeigManagerI{SeigManagerICaller: SeigManagerICaller{contract: contract}, SeigManagerITransactor: SeigManagerITransactor{contract: contract}, SeigManagerIFilterer: SeigManagerIFilterer{contract: contract}}, nil
  6596  }
  6597  
  6598  // NewSeigManagerICaller creates a new read-only instance of SeigManagerI, bound to a specific deployed contract.
  6599  func NewSeigManagerICaller(address common.Address, caller bind.ContractCaller) (*SeigManagerICaller, error) {
  6600  	contract, err := bindSeigManagerI(address, caller, nil, nil)
  6601  	if err != nil {
  6602  		return nil, err
  6603  	}
  6604  	return &SeigManagerICaller{contract: contract}, nil
  6605  }
  6606  
  6607  // NewSeigManagerITransactor creates a new write-only instance of SeigManagerI, bound to a specific deployed contract.
  6608  func NewSeigManagerITransactor(address common.Address, transactor bind.ContractTransactor) (*SeigManagerITransactor, error) {
  6609  	contract, err := bindSeigManagerI(address, nil, transactor, nil)
  6610  	if err != nil {
  6611  		return nil, err
  6612  	}
  6613  	return &SeigManagerITransactor{contract: contract}, nil
  6614  }
  6615  
  6616  // NewSeigManagerIFilterer creates a new log filterer instance of SeigManagerI, bound to a specific deployed contract.
  6617  func NewSeigManagerIFilterer(address common.Address, filterer bind.ContractFilterer) (*SeigManagerIFilterer, error) {
  6618  	contract, err := bindSeigManagerI(address, nil, nil, filterer)
  6619  	if err != nil {
  6620  		return nil, err
  6621  	}
  6622  	return &SeigManagerIFilterer{contract: contract}, nil
  6623  }
  6624  
  6625  // bindSeigManagerI binds a generic wrapper to an already deployed contract.
  6626  func bindSeigManagerI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  6627  	parsed, err := abi.JSON(strings.NewReader(SeigManagerIABI))
  6628  	if err != nil {
  6629  		return nil, err
  6630  	}
  6631  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  6632  }
  6633  
  6634  // Call invokes the (constant) contract method with params as input values and
  6635  // sets the output to result. The result type might be a single field for simple
  6636  // returns, a slice of interfaces for anonymous returns and a struct for named
  6637  // returns.
  6638  func (_SeigManagerI *SeigManagerIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  6639  	return _SeigManagerI.Contract.SeigManagerICaller.contract.Call(opts, result, method, params...)
  6640  }
  6641  
  6642  // Transfer initiates a plain transaction to move funds to the contract, calling
  6643  // its default method if one is available.
  6644  func (_SeigManagerI *SeigManagerIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  6645  	return _SeigManagerI.Contract.SeigManagerITransactor.contract.Transfer(opts)
  6646  }
  6647  
  6648  // Transact invokes the (paid) contract method with params as input values.
  6649  func (_SeigManagerI *SeigManagerIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  6650  	return _SeigManagerI.Contract.SeigManagerITransactor.contract.Transact(opts, method, params...)
  6651  }
  6652  
  6653  // Call invokes the (constant) contract method with params as input values and
  6654  // sets the output to result. The result type might be a single field for simple
  6655  // returns, a slice of interfaces for anonymous returns and a struct for named
  6656  // returns.
  6657  func (_SeigManagerI *SeigManagerICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  6658  	return _SeigManagerI.Contract.contract.Call(opts, result, method, params...)
  6659  }
  6660  
  6661  // Transfer initiates a plain transaction to move funds to the contract, calling
  6662  // its default method if one is available.
  6663  func (_SeigManagerI *SeigManagerITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  6664  	return _SeigManagerI.Contract.contract.Transfer(opts)
  6665  }
  6666  
  6667  // Transact invokes the (paid) contract method with params as input values.
  6668  func (_SeigManagerI *SeigManagerITransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  6669  	return _SeigManagerI.Contract.contract.Transact(opts, method, params...)
  6670  }
  6671  
  6672  // DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4.
  6673  //
  6674  // Solidity: function DEFAULT_FACTOR() constant returns(uint256)
  6675  func (_SeigManagerI *SeigManagerICaller) DEFAULTFACTOR(opts *bind.CallOpts) (*big.Int, error) {
  6676  	var (
  6677  		ret0 = new(*big.Int)
  6678  	)
  6679  	out := ret0
  6680  	err := _SeigManagerI.contract.Call(opts, out, "DEFAULT_FACTOR")
  6681  	return *ret0, err
  6682  }
  6683  
  6684  // DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4.
  6685  //
  6686  // Solidity: function DEFAULT_FACTOR() constant returns(uint256)
  6687  func (_SeigManagerI *SeigManagerISession) DEFAULTFACTOR() (*big.Int, error) {
  6688  	return _SeigManagerI.Contract.DEFAULTFACTOR(&_SeigManagerI.CallOpts)
  6689  }
  6690  
  6691  // DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4.
  6692  //
  6693  // Solidity: function DEFAULT_FACTOR() constant returns(uint256)
  6694  func (_SeigManagerI *SeigManagerICallerSession) DEFAULTFACTOR() (*big.Int, error) {
  6695  	return _SeigManagerI.Contract.DEFAULTFACTOR(&_SeigManagerI.CallOpts)
  6696  }
  6697  
  6698  // AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e.
  6699  //
  6700  // Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount)
  6701  func (_SeigManagerI *SeigManagerICaller) AdditionalTotBurnAmount(opts *bind.CallOpts, rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) {
  6702  	var (
  6703  		ret0 = new(*big.Int)
  6704  	)
  6705  	out := ret0
  6706  	err := _SeigManagerI.contract.Call(opts, out, "additionalTotBurnAmount", rootchain, account, amount)
  6707  	return *ret0, err
  6708  }
  6709  
  6710  // AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e.
  6711  //
  6712  // Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount)
  6713  func (_SeigManagerI *SeigManagerISession) AdditionalTotBurnAmount(rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) {
  6714  	return _SeigManagerI.Contract.AdditionalTotBurnAmount(&_SeigManagerI.CallOpts, rootchain, account, amount)
  6715  }
  6716  
  6717  // AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e.
  6718  //
  6719  // Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount)
  6720  func (_SeigManagerI *SeigManagerICallerSession) AdditionalTotBurnAmount(rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) {
  6721  	return _SeigManagerI.Contract.AdditionalTotBurnAmount(&_SeigManagerI.CallOpts, rootchain, account, amount)
  6722  }
  6723  
  6724  // Coinages is a free data retrieval call binding the contract method 0x4c063c19.
  6725  //
  6726  // Solidity: function coinages(address rootchain) constant returns(address)
  6727  func (_SeigManagerI *SeigManagerICaller) Coinages(opts *bind.CallOpts, rootchain common.Address) (common.Address, error) {
  6728  	var (
  6729  		ret0 = new(common.Address)
  6730  	)
  6731  	out := ret0
  6732  	err := _SeigManagerI.contract.Call(opts, out, "coinages", rootchain)
  6733  	return *ret0, err
  6734  }
  6735  
  6736  // Coinages is a free data retrieval call binding the contract method 0x4c063c19.
  6737  //
  6738  // Solidity: function coinages(address rootchain) constant returns(address)
  6739  func (_SeigManagerI *SeigManagerISession) Coinages(rootchain common.Address) (common.Address, error) {
  6740  	return _SeigManagerI.Contract.Coinages(&_SeigManagerI.CallOpts, rootchain)
  6741  }
  6742  
  6743  // Coinages is a free data retrieval call binding the contract method 0x4c063c19.
  6744  //
  6745  // Solidity: function coinages(address rootchain) constant returns(address)
  6746  func (_SeigManagerI *SeigManagerICallerSession) Coinages(rootchain common.Address) (common.Address, error) {
  6747  	return _SeigManagerI.Contract.Coinages(&_SeigManagerI.CallOpts, rootchain)
  6748  }
  6749  
  6750  // CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b.
  6751  //
  6752  // Solidity: function commissionRates(address rootchain) constant returns(uint256)
  6753  func (_SeigManagerI *SeigManagerICaller) CommissionRates(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
  6754  	var (
  6755  		ret0 = new(*big.Int)
  6756  	)
  6757  	out := ret0
  6758  	err := _SeigManagerI.contract.Call(opts, out, "commissionRates", rootchain)
  6759  	return *ret0, err
  6760  }
  6761  
  6762  // CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b.
  6763  //
  6764  // Solidity: function commissionRates(address rootchain) constant returns(uint256)
  6765  func (_SeigManagerI *SeigManagerISession) CommissionRates(rootchain common.Address) (*big.Int, error) {
  6766  	return _SeigManagerI.Contract.CommissionRates(&_SeigManagerI.CallOpts, rootchain)
  6767  }
  6768  
  6769  // CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b.
  6770  //
  6771  // Solidity: function commissionRates(address rootchain) constant returns(uint256)
  6772  func (_SeigManagerI *SeigManagerICallerSession) CommissionRates(rootchain common.Address) (*big.Int, error) {
  6773  	return _SeigManagerI.Contract.CommissionRates(&_SeigManagerI.CallOpts, rootchain)
  6774  }
  6775  
  6776  // DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8.
  6777  //
  6778  // Solidity: function depositManager() constant returns(address)
  6779  func (_SeigManagerI *SeigManagerICaller) DepositManager(opts *bind.CallOpts) (common.Address, error) {
  6780  	var (
  6781  		ret0 = new(common.Address)
  6782  	)
  6783  	out := ret0
  6784  	err := _SeigManagerI.contract.Call(opts, out, "depositManager")
  6785  	return *ret0, err
  6786  }
  6787  
  6788  // DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8.
  6789  //
  6790  // Solidity: function depositManager() constant returns(address)
  6791  func (_SeigManagerI *SeigManagerISession) DepositManager() (common.Address, error) {
  6792  	return _SeigManagerI.Contract.DepositManager(&_SeigManagerI.CallOpts)
  6793  }
  6794  
  6795  // DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8.
  6796  //
  6797  // Solidity: function depositManager() constant returns(address)
  6798  func (_SeigManagerI *SeigManagerICallerSession) DepositManager() (common.Address, error) {
  6799  	return _SeigManagerI.Contract.DepositManager(&_SeigManagerI.CallOpts)
  6800  }
  6801  
  6802  // LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046.
  6803  //
  6804  // Solidity: function lastCommitBlock(address rootchain) constant returns(uint256)
  6805  func (_SeigManagerI *SeigManagerICaller) LastCommitBlock(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
  6806  	var (
  6807  		ret0 = new(*big.Int)
  6808  	)
  6809  	out := ret0
  6810  	err := _SeigManagerI.contract.Call(opts, out, "lastCommitBlock", rootchain)
  6811  	return *ret0, err
  6812  }
  6813  
  6814  // LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046.
  6815  //
  6816  // Solidity: function lastCommitBlock(address rootchain) constant returns(uint256)
  6817  func (_SeigManagerI *SeigManagerISession) LastCommitBlock(rootchain common.Address) (*big.Int, error) {
  6818  	return _SeigManagerI.Contract.LastCommitBlock(&_SeigManagerI.CallOpts, rootchain)
  6819  }
  6820  
  6821  // LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046.
  6822  //
  6823  // Solidity: function lastCommitBlock(address rootchain) constant returns(uint256)
  6824  func (_SeigManagerI *SeigManagerICallerSession) LastCommitBlock(rootchain common.Address) (*big.Int, error) {
  6825  	return _SeigManagerI.Contract.LastCommitBlock(&_SeigManagerI.CallOpts, rootchain)
  6826  }
  6827  
  6828  // LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8.
  6829  //
  6830  // Solidity: function lastSeigBlock() constant returns(uint256)
  6831  func (_SeigManagerI *SeigManagerICaller) LastSeigBlock(opts *bind.CallOpts) (*big.Int, error) {
  6832  	var (
  6833  		ret0 = new(*big.Int)
  6834  	)
  6835  	out := ret0
  6836  	err := _SeigManagerI.contract.Call(opts, out, "lastSeigBlock")
  6837  	return *ret0, err
  6838  }
  6839  
  6840  // LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8.
  6841  //
  6842  // Solidity: function lastSeigBlock() constant returns(uint256)
  6843  func (_SeigManagerI *SeigManagerISession) LastSeigBlock() (*big.Int, error) {
  6844  	return _SeigManagerI.Contract.LastSeigBlock(&_SeigManagerI.CallOpts)
  6845  }
  6846  
  6847  // LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8.
  6848  //
  6849  // Solidity: function lastSeigBlock() constant returns(uint256)
  6850  func (_SeigManagerI *SeigManagerICallerSession) LastSeigBlock() (*big.Int, error) {
  6851  	return _SeigManagerI.Contract.LastSeigBlock(&_SeigManagerI.CallOpts)
  6852  }
  6853  
  6854  // PausedBlock is a free data retrieval call binding the contract method 0x32053c99.
  6855  //
  6856  // Solidity: function pausedBlock() constant returns(uint256)
  6857  func (_SeigManagerI *SeigManagerICaller) PausedBlock(opts *bind.CallOpts) (*big.Int, error) {
  6858  	var (
  6859  		ret0 = new(*big.Int)
  6860  	)
  6861  	out := ret0
  6862  	err := _SeigManagerI.contract.Call(opts, out, "pausedBlock")
  6863  	return *ret0, err
  6864  }
  6865  
  6866  // PausedBlock is a free data retrieval call binding the contract method 0x32053c99.
  6867  //
  6868  // Solidity: function pausedBlock() constant returns(uint256)
  6869  func (_SeigManagerI *SeigManagerISession) PausedBlock() (*big.Int, error) {
  6870  	return _SeigManagerI.Contract.PausedBlock(&_SeigManagerI.CallOpts)
  6871  }
  6872  
  6873  // PausedBlock is a free data retrieval call binding the contract method 0x32053c99.
  6874  //
  6875  // Solidity: function pausedBlock() constant returns(uint256)
  6876  func (_SeigManagerI *SeigManagerICallerSession) PausedBlock() (*big.Int, error) {
  6877  	return _SeigManagerI.Contract.PausedBlock(&_SeigManagerI.CallOpts)
  6878  }
  6879  
  6880  // Powerton is a free data retrieval call binding the contract method 0x3e832e1d.
  6881  //
  6882  // Solidity: function powerton() constant returns(address)
  6883  func (_SeigManagerI *SeigManagerICaller) Powerton(opts *bind.CallOpts) (common.Address, error) {
  6884  	var (
  6885  		ret0 = new(common.Address)
  6886  	)
  6887  	out := ret0
  6888  	err := _SeigManagerI.contract.Call(opts, out, "powerton")
  6889  	return *ret0, err
  6890  }
  6891  
  6892  // Powerton is a free data retrieval call binding the contract method 0x3e832e1d.
  6893  //
  6894  // Solidity: function powerton() constant returns(address)
  6895  func (_SeigManagerI *SeigManagerISession) Powerton() (common.Address, error) {
  6896  	return _SeigManagerI.Contract.Powerton(&_SeigManagerI.CallOpts)
  6897  }
  6898  
  6899  // Powerton is a free data retrieval call binding the contract method 0x3e832e1d.
  6900  //
  6901  // Solidity: function powerton() constant returns(address)
  6902  func (_SeigManagerI *SeigManagerICallerSession) Powerton() (common.Address, error) {
  6903  	return _SeigManagerI.Contract.Powerton(&_SeigManagerI.CallOpts)
  6904  }
  6905  
  6906  // Registry is a free data retrieval call binding the contract method 0x7b103999.
  6907  //
  6908  // Solidity: function registry() constant returns(address)
  6909  func (_SeigManagerI *SeigManagerICaller) Registry(opts *bind.CallOpts) (common.Address, error) {
  6910  	var (
  6911  		ret0 = new(common.Address)
  6912  	)
  6913  	out := ret0
  6914  	err := _SeigManagerI.contract.Call(opts, out, "registry")
  6915  	return *ret0, err
  6916  }
  6917  
  6918  // Registry is a free data retrieval call binding the contract method 0x7b103999.
  6919  //
  6920  // Solidity: function registry() constant returns(address)
  6921  func (_SeigManagerI *SeigManagerISession) Registry() (common.Address, error) {
  6922  	return _SeigManagerI.Contract.Registry(&_SeigManagerI.CallOpts)
  6923  }
  6924  
  6925  // Registry is a free data retrieval call binding the contract method 0x7b103999.
  6926  //
  6927  // Solidity: function registry() constant returns(address)
  6928  func (_SeigManagerI *SeigManagerICallerSession) Registry() (common.Address, error) {
  6929  	return _SeigManagerI.Contract.Registry(&_SeigManagerI.CallOpts)
  6930  }
  6931  
  6932  // SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
  6933  //
  6934  // Solidity: function seigPerBlock() constant returns(uint256)
  6935  func (_SeigManagerI *SeigManagerICaller) SeigPerBlock(opts *bind.CallOpts) (*big.Int, error) {
  6936  	var (
  6937  		ret0 = new(*big.Int)
  6938  	)
  6939  	out := ret0
  6940  	err := _SeigManagerI.contract.Call(opts, out, "seigPerBlock")
  6941  	return *ret0, err
  6942  }
  6943  
  6944  // SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
  6945  //
  6946  // Solidity: function seigPerBlock() constant returns(uint256)
  6947  func (_SeigManagerI *SeigManagerISession) SeigPerBlock() (*big.Int, error) {
  6948  	return _SeigManagerI.Contract.SeigPerBlock(&_SeigManagerI.CallOpts)
  6949  }
  6950  
  6951  // SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
  6952  //
  6953  // Solidity: function seigPerBlock() constant returns(uint256)
  6954  func (_SeigManagerI *SeigManagerICallerSession) SeigPerBlock() (*big.Int, error) {
  6955  	return _SeigManagerI.Contract.SeigPerBlock(&_SeigManagerI.CallOpts)
  6956  }
  6957  
  6958  // StakeOf is a free data retrieval call binding the contract method 0xce4cb876.
  6959  //
  6960  // Solidity: function stakeOf(address rootchain, address account) constant returns(uint256)
  6961  func (_SeigManagerI *SeigManagerICaller) StakeOf(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
  6962  	var (
  6963  		ret0 = new(*big.Int)
  6964  	)
  6965  	out := ret0
  6966  	err := _SeigManagerI.contract.Call(opts, out, "stakeOf", rootchain, account)
  6967  	return *ret0, err
  6968  }
  6969  
  6970  // StakeOf is a free data retrieval call binding the contract method 0xce4cb876.
  6971  //
  6972  // Solidity: function stakeOf(address rootchain, address account) constant returns(uint256)
  6973  func (_SeigManagerI *SeigManagerISession) StakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
  6974  	return _SeigManagerI.Contract.StakeOf(&_SeigManagerI.CallOpts, rootchain, account)
  6975  }
  6976  
  6977  // StakeOf is a free data retrieval call binding the contract method 0xce4cb876.
  6978  //
  6979  // Solidity: function stakeOf(address rootchain, address account) constant returns(uint256)
  6980  func (_SeigManagerI *SeigManagerICallerSession) StakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
  6981  	return _SeigManagerI.Contract.StakeOf(&_SeigManagerI.CallOpts, rootchain, account)
  6982  }
  6983  
  6984  // Ton is a free data retrieval call binding the contract method 0xcc48b947.
  6985  //
  6986  // Solidity: function ton() constant returns(address)
  6987  func (_SeigManagerI *SeigManagerICaller) Ton(opts *bind.CallOpts) (common.Address, error) {
  6988  	var (
  6989  		ret0 = new(common.Address)
  6990  	)
  6991  	out := ret0
  6992  	err := _SeigManagerI.contract.Call(opts, out, "ton")
  6993  	return *ret0, err
  6994  }
  6995  
  6996  // Ton is a free data retrieval call binding the contract method 0xcc48b947.
  6997  //
  6998  // Solidity: function ton() constant returns(address)
  6999  func (_SeigManagerI *SeigManagerISession) Ton() (common.Address, error) {
  7000  	return _SeigManagerI.Contract.Ton(&_SeigManagerI.CallOpts)
  7001  }
  7002  
  7003  // Ton is a free data retrieval call binding the contract method 0xcc48b947.
  7004  //
  7005  // Solidity: function ton() constant returns(address)
  7006  func (_SeigManagerI *SeigManagerICallerSession) Ton() (common.Address, error) {
  7007  	return _SeigManagerI.Contract.Ton(&_SeigManagerI.CallOpts)
  7008  }
  7009  
  7010  // Tot is a free data retrieval call binding the contract method 0xa16d6aa7.
  7011  //
  7012  // Solidity: function tot() constant returns(address)
  7013  func (_SeigManagerI *SeigManagerICaller) Tot(opts *bind.CallOpts) (common.Address, error) {
  7014  	var (
  7015  		ret0 = new(common.Address)
  7016  	)
  7017  	out := ret0
  7018  	err := _SeigManagerI.contract.Call(opts, out, "tot")
  7019  	return *ret0, err
  7020  }
  7021  
  7022  // Tot is a free data retrieval call binding the contract method 0xa16d6aa7.
  7023  //
  7024  // Solidity: function tot() constant returns(address)
  7025  func (_SeigManagerI *SeigManagerISession) Tot() (common.Address, error) {
  7026  	return _SeigManagerI.Contract.Tot(&_SeigManagerI.CallOpts)
  7027  }
  7028  
  7029  // Tot is a free data retrieval call binding the contract method 0xa16d6aa7.
  7030  //
  7031  // Solidity: function tot() constant returns(address)
  7032  func (_SeigManagerI *SeigManagerICallerSession) Tot() (common.Address, error) {
  7033  	return _SeigManagerI.Contract.Tot(&_SeigManagerI.CallOpts)
  7034  }
  7035  
  7036  // UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8.
  7037  //
  7038  // Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256)
  7039  func (_SeigManagerI *SeigManagerICaller) UncomittedStakeOf(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
  7040  	var (
  7041  		ret0 = new(*big.Int)
  7042  	)
  7043  	out := ret0
  7044  	err := _SeigManagerI.contract.Call(opts, out, "uncomittedStakeOf", rootchain, account)
  7045  	return *ret0, err
  7046  }
  7047  
  7048  // UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8.
  7049  //
  7050  // Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256)
  7051  func (_SeigManagerI *SeigManagerISession) UncomittedStakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
  7052  	return _SeigManagerI.Contract.UncomittedStakeOf(&_SeigManagerI.CallOpts, rootchain, account)
  7053  }
  7054  
  7055  // UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8.
  7056  //
  7057  // Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256)
  7058  func (_SeigManagerI *SeigManagerICallerSession) UncomittedStakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
  7059  	return _SeigManagerI.Contract.UncomittedStakeOf(&_SeigManagerI.CallOpts, rootchain, account)
  7060  }
  7061  
  7062  // UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890.
  7063  //
  7064  // Solidity: function unpausedBlock() constant returns(uint256)
  7065  func (_SeigManagerI *SeigManagerICaller) UnpausedBlock(opts *bind.CallOpts) (*big.Int, error) {
  7066  	var (
  7067  		ret0 = new(*big.Int)
  7068  	)
  7069  	out := ret0
  7070  	err := _SeigManagerI.contract.Call(opts, out, "unpausedBlock")
  7071  	return *ret0, err
  7072  }
  7073  
  7074  // UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890.
  7075  //
  7076  // Solidity: function unpausedBlock() constant returns(uint256)
  7077  func (_SeigManagerI *SeigManagerISession) UnpausedBlock() (*big.Int, error) {
  7078  	return _SeigManagerI.Contract.UnpausedBlock(&_SeigManagerI.CallOpts)
  7079  }
  7080  
  7081  // UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890.
  7082  //
  7083  // Solidity: function unpausedBlock() constant returns(uint256)
  7084  func (_SeigManagerI *SeigManagerICallerSession) UnpausedBlock() (*big.Int, error) {
  7085  	return _SeigManagerI.Contract.UnpausedBlock(&_SeigManagerI.CallOpts)
  7086  }
  7087  
  7088  // Wton is a free data retrieval call binding the contract method 0x8d62d949.
  7089  //
  7090  // Solidity: function wton() constant returns(address)
  7091  func (_SeigManagerI *SeigManagerICaller) Wton(opts *bind.CallOpts) (common.Address, error) {
  7092  	var (
  7093  		ret0 = new(common.Address)
  7094  	)
  7095  	out := ret0
  7096  	err := _SeigManagerI.contract.Call(opts, out, "wton")
  7097  	return *ret0, err
  7098  }
  7099  
  7100  // Wton is a free data retrieval call binding the contract method 0x8d62d949.
  7101  //
  7102  // Solidity: function wton() constant returns(address)
  7103  func (_SeigManagerI *SeigManagerISession) Wton() (common.Address, error) {
  7104  	return _SeigManagerI.Contract.Wton(&_SeigManagerI.CallOpts)
  7105  }
  7106  
  7107  // Wton is a free data retrieval call binding the contract method 0x8d62d949.
  7108  //
  7109  // Solidity: function wton() constant returns(address)
  7110  func (_SeigManagerI *SeigManagerICallerSession) Wton() (common.Address, error) {
  7111  	return _SeigManagerI.Contract.Wton(&_SeigManagerI.CallOpts)
  7112  }
  7113  
  7114  // DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f.
  7115  //
  7116  // Solidity: function deployCoinage(address rootchain) returns(bool)
  7117  func (_SeigManagerI *SeigManagerITransactor) DeployCoinage(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) {
  7118  	return _SeigManagerI.contract.Transact(opts, "deployCoinage", rootchain)
  7119  }
  7120  
  7121  // DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f.
  7122  //
  7123  // Solidity: function deployCoinage(address rootchain) returns(bool)
  7124  func (_SeigManagerI *SeigManagerISession) DeployCoinage(rootchain common.Address) (*types.Transaction, error) {
  7125  	return _SeigManagerI.Contract.DeployCoinage(&_SeigManagerI.TransactOpts, rootchain)
  7126  }
  7127  
  7128  // DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f.
  7129  //
  7130  // Solidity: function deployCoinage(address rootchain) returns(bool)
  7131  func (_SeigManagerI *SeigManagerITransactorSession) DeployCoinage(rootchain common.Address) (*types.Transaction, error) {
  7132  	return _SeigManagerI.Contract.DeployCoinage(&_SeigManagerI.TransactOpts, rootchain)
  7133  }
  7134  
  7135  // OnCommit is a paid mutator transaction binding the contract method 0x359c4d59.
  7136  //
  7137  // Solidity: function onCommit() returns(bool)
  7138  func (_SeigManagerI *SeigManagerITransactor) OnCommit(opts *bind.TransactOpts) (*types.Transaction, error) {
  7139  	return _SeigManagerI.contract.Transact(opts, "onCommit")
  7140  }
  7141  
  7142  // OnCommit is a paid mutator transaction binding the contract method 0x359c4d59.
  7143  //
  7144  // Solidity: function onCommit() returns(bool)
  7145  func (_SeigManagerI *SeigManagerISession) OnCommit() (*types.Transaction, error) {
  7146  	return _SeigManagerI.Contract.OnCommit(&_SeigManagerI.TransactOpts)
  7147  }
  7148  
  7149  // OnCommit is a paid mutator transaction binding the contract method 0x359c4d59.
  7150  //
  7151  // Solidity: function onCommit() returns(bool)
  7152  func (_SeigManagerI *SeigManagerITransactorSession) OnCommit() (*types.Transaction, error) {
  7153  	return _SeigManagerI.Contract.OnCommit(&_SeigManagerI.TransactOpts)
  7154  }
  7155  
  7156  // OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50.
  7157  //
  7158  // Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool)
  7159  func (_SeigManagerI *SeigManagerITransactor) OnDeposit(opts *bind.TransactOpts, rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
  7160  	return _SeigManagerI.contract.Transact(opts, "onDeposit", rootchain, account, amount)
  7161  }
  7162  
  7163  // OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50.
  7164  //
  7165  // Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool)
  7166  func (_SeigManagerI *SeigManagerISession) OnDeposit(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
  7167  	return _SeigManagerI.Contract.OnDeposit(&_SeigManagerI.TransactOpts, rootchain, account, amount)
  7168  }
  7169  
  7170  // OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50.
  7171  //
  7172  // Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool)
  7173  func (_SeigManagerI *SeigManagerITransactorSession) OnDeposit(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
  7174  	return _SeigManagerI.Contract.OnDeposit(&_SeigManagerI.TransactOpts, rootchain, account, amount)
  7175  }
  7176  
  7177  // OnTransfer is a paid mutator transaction binding the contract method 0x4a393149.
  7178  //
  7179  // Solidity: function onTransfer(address sender, address recipient, uint256 amount) returns(bool)
  7180  func (_SeigManagerI *SeigManagerITransactor) OnTransfer(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7181  	return _SeigManagerI.contract.Transact(opts, "onTransfer", sender, recipient, amount)
  7182  }
  7183  
  7184  // OnTransfer is a paid mutator transaction binding the contract method 0x4a393149.
  7185  //
  7186  // Solidity: function onTransfer(address sender, address recipient, uint256 amount) returns(bool)
  7187  func (_SeigManagerI *SeigManagerISession) OnTransfer(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7188  	return _SeigManagerI.Contract.OnTransfer(&_SeigManagerI.TransactOpts, sender, recipient, amount)
  7189  }
  7190  
  7191  // OnTransfer is a paid mutator transaction binding the contract method 0x4a393149.
  7192  //
  7193  // Solidity: function onTransfer(address sender, address recipient, uint256 amount) returns(bool)
  7194  func (_SeigManagerI *SeigManagerITransactorSession) OnTransfer(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7195  	return _SeigManagerI.Contract.OnTransfer(&_SeigManagerI.TransactOpts, sender, recipient, amount)
  7196  }
  7197  
  7198  // OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa.
  7199  //
  7200  // Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool)
  7201  func (_SeigManagerI *SeigManagerITransactor) OnWithdraw(opts *bind.TransactOpts, rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
  7202  	return _SeigManagerI.contract.Transact(opts, "onWithdraw", rootchain, account, amount)
  7203  }
  7204  
  7205  // OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa.
  7206  //
  7207  // Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool)
  7208  func (_SeigManagerI *SeigManagerISession) OnWithdraw(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
  7209  	return _SeigManagerI.Contract.OnWithdraw(&_SeigManagerI.TransactOpts, rootchain, account, amount)
  7210  }
  7211  
  7212  // OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa.
  7213  //
  7214  // Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool)
  7215  func (_SeigManagerI *SeigManagerITransactorSession) OnWithdraw(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
  7216  	return _SeigManagerI.Contract.OnWithdraw(&_SeigManagerI.TransactOpts, rootchain, account, amount)
  7217  }
  7218  
  7219  // SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66.
  7220  //
  7221  // Solidity: function setCommissionRate(address rootchain, uint256 commission, bool isCommissionRateNegative) returns(bool)
  7222  func (_SeigManagerI *SeigManagerITransactor) SetCommissionRate(opts *bind.TransactOpts, rootchain common.Address, commission *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) {
  7223  	return _SeigManagerI.contract.Transact(opts, "setCommissionRate", rootchain, commission, isCommissionRateNegative)
  7224  }
  7225  
  7226  // SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66.
  7227  //
  7228  // Solidity: function setCommissionRate(address rootchain, uint256 commission, bool isCommissionRateNegative) returns(bool)
  7229  func (_SeigManagerI *SeigManagerISession) SetCommissionRate(rootchain common.Address, commission *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) {
  7230  	return _SeigManagerI.Contract.SetCommissionRate(&_SeigManagerI.TransactOpts, rootchain, commission, isCommissionRateNegative)
  7231  }
  7232  
  7233  // SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66.
  7234  //
  7235  // Solidity: function setCommissionRate(address rootchain, uint256 commission, bool isCommissionRateNegative) returns(bool)
  7236  func (_SeigManagerI *SeigManagerITransactorSession) SetCommissionRate(rootchain common.Address, commission *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) {
  7237  	return _SeigManagerI.Contract.SetCommissionRate(&_SeigManagerI.TransactOpts, rootchain, commission, isCommissionRateNegative)
  7238  }
  7239  
  7240  // SeigTokenABI is the input ABI used to generate the binding from.
  7241  const SeigTokenABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"INTERFACE_ID_ON_APPROVE\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"approveAndCall\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigManager\",\"outputs\":[{\"internalType\":\"contractSeigManagerI\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"contractSeigManagerI\",\"name\":\"_seigManager\",\"type\":\"address\"}],\"name\":\"setSeigManager\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
  7242  
  7243  // SeigTokenFuncSigs maps the 4-byte function signature to its string representation.
  7244  var SeigTokenFuncSigs = map[string]string{
  7245  	"6cd28f9a": "INTERFACE_ID_ON_APPROVE()",
  7246  	"dd62ed3e": "allowance(address,address)",
  7247  	"095ea7b3": "approve(address,uint256)",
  7248  	"cae9ca51": "approveAndCall(address,uint256,bytes)",
  7249  	"70a08231": "balanceOf(address)",
  7250  	"a457c2d7": "decreaseAllowance(address,uint256)",
  7251  	"39509351": "increaseAllowance(address,uint256)",
  7252  	"8f32d59b": "isOwner()",
  7253  	"8da5cb5b": "owner()",
  7254  	"5f112c68": "renounceMinter(address)",
  7255  	"715018a6": "renounceOwnership()",
  7256  	"38bf3cfa": "renounceOwnership(address)",
  7257  	"41eb24bb": "renouncePauser(address)",
  7258  	"6fb7f558": "seigManager()",
  7259  	"7657f20a": "setSeigManager(address)",
  7260  	"18160ddd": "totalSupply()",
  7261  	"a9059cbb": "transfer(address,uint256)",
  7262  	"23b872dd": "transferFrom(address,address,uint256)",
  7263  	"f2fde38b": "transferOwnership(address)",
  7264  	"6d435421": "transferOwnership(address,address)",
  7265  }
  7266  
  7267  // SeigTokenBin is the compiled bytecode used for deploying new contracts.
  7268  var SeigTokenBin = "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"
  7269  
  7270  // DeploySeigToken deploys a new Ethereum contract, binding an instance of SeigToken to it.
  7271  func DeploySeigToken(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SeigToken, error) {
  7272  	parsed, err := abi.JSON(strings.NewReader(SeigTokenABI))
  7273  	if err != nil {
  7274  		return common.Address{}, nil, nil, err
  7275  	}
  7276  
  7277  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SeigTokenBin), backend)
  7278  	if err != nil {
  7279  		return common.Address{}, nil, nil, err
  7280  	}
  7281  	return address, tx, &SeigToken{SeigTokenCaller: SeigTokenCaller{contract: contract}, SeigTokenTransactor: SeigTokenTransactor{contract: contract}, SeigTokenFilterer: SeigTokenFilterer{contract: contract}}, nil
  7282  }
  7283  
  7284  // SeigToken is an auto generated Go binding around an Ethereum contract.
  7285  type SeigToken struct {
  7286  	SeigTokenCaller     // Read-only binding to the contract
  7287  	SeigTokenTransactor // Write-only binding to the contract
  7288  	SeigTokenFilterer   // Log filterer for contract events
  7289  }
  7290  
  7291  // SeigTokenCaller is an auto generated read-only Go binding around an Ethereum contract.
  7292  type SeigTokenCaller struct {
  7293  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  7294  }
  7295  
  7296  // SeigTokenTransactor is an auto generated write-only Go binding around an Ethereum contract.
  7297  type SeigTokenTransactor struct {
  7298  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  7299  }
  7300  
  7301  // SeigTokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  7302  type SeigTokenFilterer struct {
  7303  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  7304  }
  7305  
  7306  // SeigTokenSession is an auto generated Go binding around an Ethereum contract,
  7307  // with pre-set call and transact options.
  7308  type SeigTokenSession struct {
  7309  	Contract     *SeigToken        // Generic contract binding to set the session for
  7310  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  7311  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  7312  }
  7313  
  7314  // SeigTokenCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  7315  // with pre-set call options.
  7316  type SeigTokenCallerSession struct {
  7317  	Contract *SeigTokenCaller // Generic contract caller binding to set the session for
  7318  	CallOpts bind.CallOpts    // Call options to use throughout this session
  7319  }
  7320  
  7321  // SeigTokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  7322  // with pre-set transact options.
  7323  type SeigTokenTransactorSession struct {
  7324  	Contract     *SeigTokenTransactor // Generic contract transactor binding to set the session for
  7325  	TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
  7326  }
  7327  
  7328  // SeigTokenRaw is an auto generated low-level Go binding around an Ethereum contract.
  7329  type SeigTokenRaw struct {
  7330  	Contract *SeigToken // Generic contract binding to access the raw methods on
  7331  }
  7332  
  7333  // SeigTokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  7334  type SeigTokenCallerRaw struct {
  7335  	Contract *SeigTokenCaller // Generic read-only contract binding to access the raw methods on
  7336  }
  7337  
  7338  // SeigTokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  7339  type SeigTokenTransactorRaw struct {
  7340  	Contract *SeigTokenTransactor // Generic write-only contract binding to access the raw methods on
  7341  }
  7342  
  7343  // NewSeigToken creates a new instance of SeigToken, bound to a specific deployed contract.
  7344  func NewSeigToken(address common.Address, backend bind.ContractBackend) (*SeigToken, error) {
  7345  	contract, err := bindSeigToken(address, backend, backend, backend)
  7346  	if err != nil {
  7347  		return nil, err
  7348  	}
  7349  	return &SeigToken{SeigTokenCaller: SeigTokenCaller{contract: contract}, SeigTokenTransactor: SeigTokenTransactor{contract: contract}, SeigTokenFilterer: SeigTokenFilterer{contract: contract}}, nil
  7350  }
  7351  
  7352  // NewSeigTokenCaller creates a new read-only instance of SeigToken, bound to a specific deployed contract.
  7353  func NewSeigTokenCaller(address common.Address, caller bind.ContractCaller) (*SeigTokenCaller, error) {
  7354  	contract, err := bindSeigToken(address, caller, nil, nil)
  7355  	if err != nil {
  7356  		return nil, err
  7357  	}
  7358  	return &SeigTokenCaller{contract: contract}, nil
  7359  }
  7360  
  7361  // NewSeigTokenTransactor creates a new write-only instance of SeigToken, bound to a specific deployed contract.
  7362  func NewSeigTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*SeigTokenTransactor, error) {
  7363  	contract, err := bindSeigToken(address, nil, transactor, nil)
  7364  	if err != nil {
  7365  		return nil, err
  7366  	}
  7367  	return &SeigTokenTransactor{contract: contract}, nil
  7368  }
  7369  
  7370  // NewSeigTokenFilterer creates a new log filterer instance of SeigToken, bound to a specific deployed contract.
  7371  func NewSeigTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*SeigTokenFilterer, error) {
  7372  	contract, err := bindSeigToken(address, nil, nil, filterer)
  7373  	if err != nil {
  7374  		return nil, err
  7375  	}
  7376  	return &SeigTokenFilterer{contract: contract}, nil
  7377  }
  7378  
  7379  // bindSeigToken binds a generic wrapper to an already deployed contract.
  7380  func bindSeigToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  7381  	parsed, err := abi.JSON(strings.NewReader(SeigTokenABI))
  7382  	if err != nil {
  7383  		return nil, err
  7384  	}
  7385  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  7386  }
  7387  
  7388  // Call invokes the (constant) contract method with params as input values and
  7389  // sets the output to result. The result type might be a single field for simple
  7390  // returns, a slice of interfaces for anonymous returns and a struct for named
  7391  // returns.
  7392  func (_SeigToken *SeigTokenRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  7393  	return _SeigToken.Contract.SeigTokenCaller.contract.Call(opts, result, method, params...)
  7394  }
  7395  
  7396  // Transfer initiates a plain transaction to move funds to the contract, calling
  7397  // its default method if one is available.
  7398  func (_SeigToken *SeigTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  7399  	return _SeigToken.Contract.SeigTokenTransactor.contract.Transfer(opts)
  7400  }
  7401  
  7402  // Transact invokes the (paid) contract method with params as input values.
  7403  func (_SeigToken *SeigTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  7404  	return _SeigToken.Contract.SeigTokenTransactor.contract.Transact(opts, method, params...)
  7405  }
  7406  
  7407  // Call invokes the (constant) contract method with params as input values and
  7408  // sets the output to result. The result type might be a single field for simple
  7409  // returns, a slice of interfaces for anonymous returns and a struct for named
  7410  // returns.
  7411  func (_SeigToken *SeigTokenCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  7412  	return _SeigToken.Contract.contract.Call(opts, result, method, params...)
  7413  }
  7414  
  7415  // Transfer initiates a plain transaction to move funds to the contract, calling
  7416  // its default method if one is available.
  7417  func (_SeigToken *SeigTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  7418  	return _SeigToken.Contract.contract.Transfer(opts)
  7419  }
  7420  
  7421  // Transact invokes the (paid) contract method with params as input values.
  7422  func (_SeigToken *SeigTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  7423  	return _SeigToken.Contract.contract.Transact(opts, method, params...)
  7424  }
  7425  
  7426  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  7427  //
  7428  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  7429  func (_SeigToken *SeigTokenCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) {
  7430  	var (
  7431  		ret0 = new([4]byte)
  7432  	)
  7433  	out := ret0
  7434  	err := _SeigToken.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE")
  7435  	return *ret0, err
  7436  }
  7437  
  7438  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  7439  //
  7440  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  7441  func (_SeigToken *SeigTokenSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  7442  	return _SeigToken.Contract.INTERFACEIDONAPPROVE(&_SeigToken.CallOpts)
  7443  }
  7444  
  7445  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  7446  //
  7447  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  7448  func (_SeigToken *SeigTokenCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  7449  	return _SeigToken.Contract.INTERFACEIDONAPPROVE(&_SeigToken.CallOpts)
  7450  }
  7451  
  7452  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  7453  //
  7454  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  7455  func (_SeigToken *SeigTokenCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
  7456  	var (
  7457  		ret0 = new(*big.Int)
  7458  	)
  7459  	out := ret0
  7460  	err := _SeigToken.contract.Call(opts, out, "allowance", owner, spender)
  7461  	return *ret0, err
  7462  }
  7463  
  7464  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  7465  //
  7466  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  7467  func (_SeigToken *SeigTokenSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  7468  	return _SeigToken.Contract.Allowance(&_SeigToken.CallOpts, owner, spender)
  7469  }
  7470  
  7471  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  7472  //
  7473  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  7474  func (_SeigToken *SeigTokenCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  7475  	return _SeigToken.Contract.Allowance(&_SeigToken.CallOpts, owner, spender)
  7476  }
  7477  
  7478  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  7479  //
  7480  // Solidity: function balanceOf(address account) constant returns(uint256)
  7481  func (_SeigToken *SeigTokenCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  7482  	var (
  7483  		ret0 = new(*big.Int)
  7484  	)
  7485  	out := ret0
  7486  	err := _SeigToken.contract.Call(opts, out, "balanceOf", account)
  7487  	return *ret0, err
  7488  }
  7489  
  7490  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  7491  //
  7492  // Solidity: function balanceOf(address account) constant returns(uint256)
  7493  func (_SeigToken *SeigTokenSession) BalanceOf(account common.Address) (*big.Int, error) {
  7494  	return _SeigToken.Contract.BalanceOf(&_SeigToken.CallOpts, account)
  7495  }
  7496  
  7497  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  7498  //
  7499  // Solidity: function balanceOf(address account) constant returns(uint256)
  7500  func (_SeigToken *SeigTokenCallerSession) BalanceOf(account common.Address) (*big.Int, error) {
  7501  	return _SeigToken.Contract.BalanceOf(&_SeigToken.CallOpts, account)
  7502  }
  7503  
  7504  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
  7505  //
  7506  // Solidity: function isOwner() constant returns(bool)
  7507  func (_SeigToken *SeigTokenCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
  7508  	var (
  7509  		ret0 = new(bool)
  7510  	)
  7511  	out := ret0
  7512  	err := _SeigToken.contract.Call(opts, out, "isOwner")
  7513  	return *ret0, err
  7514  }
  7515  
  7516  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
  7517  //
  7518  // Solidity: function isOwner() constant returns(bool)
  7519  func (_SeigToken *SeigTokenSession) IsOwner() (bool, error) {
  7520  	return _SeigToken.Contract.IsOwner(&_SeigToken.CallOpts)
  7521  }
  7522  
  7523  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
  7524  //
  7525  // Solidity: function isOwner() constant returns(bool)
  7526  func (_SeigToken *SeigTokenCallerSession) IsOwner() (bool, error) {
  7527  	return _SeigToken.Contract.IsOwner(&_SeigToken.CallOpts)
  7528  }
  7529  
  7530  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  7531  //
  7532  // Solidity: function owner() constant returns(address)
  7533  func (_SeigToken *SeigTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
  7534  	var (
  7535  		ret0 = new(common.Address)
  7536  	)
  7537  	out := ret0
  7538  	err := _SeigToken.contract.Call(opts, out, "owner")
  7539  	return *ret0, err
  7540  }
  7541  
  7542  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  7543  //
  7544  // Solidity: function owner() constant returns(address)
  7545  func (_SeigToken *SeigTokenSession) Owner() (common.Address, error) {
  7546  	return _SeigToken.Contract.Owner(&_SeigToken.CallOpts)
  7547  }
  7548  
  7549  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  7550  //
  7551  // Solidity: function owner() constant returns(address)
  7552  func (_SeigToken *SeigTokenCallerSession) Owner() (common.Address, error) {
  7553  	return _SeigToken.Contract.Owner(&_SeigToken.CallOpts)
  7554  }
  7555  
  7556  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
  7557  //
  7558  // Solidity: function seigManager() constant returns(address)
  7559  func (_SeigToken *SeigTokenCaller) SeigManager(opts *bind.CallOpts) (common.Address, error) {
  7560  	var (
  7561  		ret0 = new(common.Address)
  7562  	)
  7563  	out := ret0
  7564  	err := _SeigToken.contract.Call(opts, out, "seigManager")
  7565  	return *ret0, err
  7566  }
  7567  
  7568  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
  7569  //
  7570  // Solidity: function seigManager() constant returns(address)
  7571  func (_SeigToken *SeigTokenSession) SeigManager() (common.Address, error) {
  7572  	return _SeigToken.Contract.SeigManager(&_SeigToken.CallOpts)
  7573  }
  7574  
  7575  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
  7576  //
  7577  // Solidity: function seigManager() constant returns(address)
  7578  func (_SeigToken *SeigTokenCallerSession) SeigManager() (common.Address, error) {
  7579  	return _SeigToken.Contract.SeigManager(&_SeigToken.CallOpts)
  7580  }
  7581  
  7582  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  7583  //
  7584  // Solidity: function totalSupply() constant returns(uint256)
  7585  func (_SeigToken *SeigTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
  7586  	var (
  7587  		ret0 = new(*big.Int)
  7588  	)
  7589  	out := ret0
  7590  	err := _SeigToken.contract.Call(opts, out, "totalSupply")
  7591  	return *ret0, err
  7592  }
  7593  
  7594  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  7595  //
  7596  // Solidity: function totalSupply() constant returns(uint256)
  7597  func (_SeigToken *SeigTokenSession) TotalSupply() (*big.Int, error) {
  7598  	return _SeigToken.Contract.TotalSupply(&_SeigToken.CallOpts)
  7599  }
  7600  
  7601  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  7602  //
  7603  // Solidity: function totalSupply() constant returns(uint256)
  7604  func (_SeigToken *SeigTokenCallerSession) TotalSupply() (*big.Int, error) {
  7605  	return _SeigToken.Contract.TotalSupply(&_SeigToken.CallOpts)
  7606  }
  7607  
  7608  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  7609  //
  7610  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  7611  func (_SeigToken *SeigTokenTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
  7612  	return _SeigToken.contract.Transact(opts, "approve", spender, amount)
  7613  }
  7614  
  7615  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  7616  //
  7617  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  7618  func (_SeigToken *SeigTokenSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  7619  	return _SeigToken.Contract.Approve(&_SeigToken.TransactOpts, spender, amount)
  7620  }
  7621  
  7622  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  7623  //
  7624  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  7625  func (_SeigToken *SeigTokenTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  7626  	return _SeigToken.Contract.Approve(&_SeigToken.TransactOpts, spender, amount)
  7627  }
  7628  
  7629  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
  7630  //
  7631  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
  7632  func (_SeigToken *SeigTokenTransactor) ApproveAndCall(opts *bind.TransactOpts, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  7633  	return _SeigToken.contract.Transact(opts, "approveAndCall", spender, amount, data)
  7634  }
  7635  
  7636  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
  7637  //
  7638  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
  7639  func (_SeigToken *SeigTokenSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  7640  	return _SeigToken.Contract.ApproveAndCall(&_SeigToken.TransactOpts, spender, amount, data)
  7641  }
  7642  
  7643  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
  7644  //
  7645  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
  7646  func (_SeigToken *SeigTokenTransactorSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  7647  	return _SeigToken.Contract.ApproveAndCall(&_SeigToken.TransactOpts, spender, amount, data)
  7648  }
  7649  
  7650  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  7651  //
  7652  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  7653  func (_SeigToken *SeigTokenTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  7654  	return _SeigToken.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
  7655  }
  7656  
  7657  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  7658  //
  7659  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  7660  func (_SeigToken *SeigTokenSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  7661  	return _SeigToken.Contract.DecreaseAllowance(&_SeigToken.TransactOpts, spender, subtractedValue)
  7662  }
  7663  
  7664  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  7665  //
  7666  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  7667  func (_SeigToken *SeigTokenTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  7668  	return _SeigToken.Contract.DecreaseAllowance(&_SeigToken.TransactOpts, spender, subtractedValue)
  7669  }
  7670  
  7671  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  7672  //
  7673  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  7674  func (_SeigToken *SeigTokenTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  7675  	return _SeigToken.contract.Transact(opts, "increaseAllowance", spender, addedValue)
  7676  }
  7677  
  7678  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  7679  //
  7680  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  7681  func (_SeigToken *SeigTokenSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  7682  	return _SeigToken.Contract.IncreaseAllowance(&_SeigToken.TransactOpts, spender, addedValue)
  7683  }
  7684  
  7685  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  7686  //
  7687  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  7688  func (_SeigToken *SeigTokenTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  7689  	return _SeigToken.Contract.IncreaseAllowance(&_SeigToken.TransactOpts, spender, addedValue)
  7690  }
  7691  
  7692  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
  7693  //
  7694  // Solidity: function renounceMinter(address target) returns()
  7695  func (_SeigToken *SeigTokenTransactor) RenounceMinter(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
  7696  	return _SeigToken.contract.Transact(opts, "renounceMinter", target)
  7697  }
  7698  
  7699  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
  7700  //
  7701  // Solidity: function renounceMinter(address target) returns()
  7702  func (_SeigToken *SeigTokenSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
  7703  	return _SeigToken.Contract.RenounceMinter(&_SeigToken.TransactOpts, target)
  7704  }
  7705  
  7706  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
  7707  //
  7708  // Solidity: function renounceMinter(address target) returns()
  7709  func (_SeigToken *SeigTokenTransactorSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
  7710  	return _SeigToken.Contract.RenounceMinter(&_SeigToken.TransactOpts, target)
  7711  }
  7712  
  7713  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
  7714  //
  7715  // Solidity: function renounceOwnership(address target) returns()
  7716  func (_SeigToken *SeigTokenTransactor) RenounceOwnership(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
  7717  	return _SeigToken.contract.Transact(opts, "renounceOwnership", target)
  7718  }
  7719  
  7720  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
  7721  //
  7722  // Solidity: function renounceOwnership(address target) returns()
  7723  func (_SeigToken *SeigTokenSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
  7724  	return _SeigToken.Contract.RenounceOwnership(&_SeigToken.TransactOpts, target)
  7725  }
  7726  
  7727  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
  7728  //
  7729  // Solidity: function renounceOwnership(address target) returns()
  7730  func (_SeigToken *SeigTokenTransactorSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
  7731  	return _SeigToken.Contract.RenounceOwnership(&_SeigToken.TransactOpts, target)
  7732  }
  7733  
  7734  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
  7735  //
  7736  // Solidity: function renounceOwnership() returns()
  7737  func (_SeigToken *SeigTokenTransactor) RenounceOwnership0(opts *bind.TransactOpts) (*types.Transaction, error) {
  7738  	return _SeigToken.contract.Transact(opts, "renounceOwnership0")
  7739  }
  7740  
  7741  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
  7742  //
  7743  // Solidity: function renounceOwnership() returns()
  7744  func (_SeigToken *SeigTokenSession) RenounceOwnership0() (*types.Transaction, error) {
  7745  	return _SeigToken.Contract.RenounceOwnership0(&_SeigToken.TransactOpts)
  7746  }
  7747  
  7748  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
  7749  //
  7750  // Solidity: function renounceOwnership() returns()
  7751  func (_SeigToken *SeigTokenTransactorSession) RenounceOwnership0() (*types.Transaction, error) {
  7752  	return _SeigToken.Contract.RenounceOwnership0(&_SeigToken.TransactOpts)
  7753  }
  7754  
  7755  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
  7756  //
  7757  // Solidity: function renouncePauser(address target) returns()
  7758  func (_SeigToken *SeigTokenTransactor) RenouncePauser(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
  7759  	return _SeigToken.contract.Transact(opts, "renouncePauser", target)
  7760  }
  7761  
  7762  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
  7763  //
  7764  // Solidity: function renouncePauser(address target) returns()
  7765  func (_SeigToken *SeigTokenSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
  7766  	return _SeigToken.Contract.RenouncePauser(&_SeigToken.TransactOpts, target)
  7767  }
  7768  
  7769  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
  7770  //
  7771  // Solidity: function renouncePauser(address target) returns()
  7772  func (_SeigToken *SeigTokenTransactorSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
  7773  	return _SeigToken.Contract.RenouncePauser(&_SeigToken.TransactOpts, target)
  7774  }
  7775  
  7776  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
  7777  //
  7778  // Solidity: function setSeigManager(address _seigManager) returns()
  7779  func (_SeigToken *SeigTokenTransactor) SetSeigManager(opts *bind.TransactOpts, _seigManager common.Address) (*types.Transaction, error) {
  7780  	return _SeigToken.contract.Transact(opts, "setSeigManager", _seigManager)
  7781  }
  7782  
  7783  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
  7784  //
  7785  // Solidity: function setSeigManager(address _seigManager) returns()
  7786  func (_SeigToken *SeigTokenSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) {
  7787  	return _SeigToken.Contract.SetSeigManager(&_SeigToken.TransactOpts, _seigManager)
  7788  }
  7789  
  7790  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
  7791  //
  7792  // Solidity: function setSeigManager(address _seigManager) returns()
  7793  func (_SeigToken *SeigTokenTransactorSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) {
  7794  	return _SeigToken.Contract.SetSeigManager(&_SeigToken.TransactOpts, _seigManager)
  7795  }
  7796  
  7797  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  7798  //
  7799  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  7800  func (_SeigToken *SeigTokenTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7801  	return _SeigToken.contract.Transact(opts, "transfer", recipient, amount)
  7802  }
  7803  
  7804  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  7805  //
  7806  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  7807  func (_SeigToken *SeigTokenSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7808  	return _SeigToken.Contract.Transfer(&_SeigToken.TransactOpts, recipient, amount)
  7809  }
  7810  
  7811  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  7812  //
  7813  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  7814  func (_SeigToken *SeigTokenTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7815  	return _SeigToken.Contract.Transfer(&_SeigToken.TransactOpts, recipient, amount)
  7816  }
  7817  
  7818  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  7819  //
  7820  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  7821  func (_SeigToken *SeigTokenTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7822  	return _SeigToken.contract.Transact(opts, "transferFrom", sender, recipient, amount)
  7823  }
  7824  
  7825  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  7826  //
  7827  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  7828  func (_SeigToken *SeigTokenSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7829  	return _SeigToken.Contract.TransferFrom(&_SeigToken.TransactOpts, sender, recipient, amount)
  7830  }
  7831  
  7832  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  7833  //
  7834  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  7835  func (_SeigToken *SeigTokenTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7836  	return _SeigToken.Contract.TransferFrom(&_SeigToken.TransactOpts, sender, recipient, amount)
  7837  }
  7838  
  7839  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
  7840  //
  7841  // Solidity: function transferOwnership(address target, address newOwner) returns()
  7842  func (_SeigToken *SeigTokenTransactor) TransferOwnership(opts *bind.TransactOpts, target common.Address, newOwner common.Address) (*types.Transaction, error) {
  7843  	return _SeigToken.contract.Transact(opts, "transferOwnership", target, newOwner)
  7844  }
  7845  
  7846  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
  7847  //
  7848  // Solidity: function transferOwnership(address target, address newOwner) returns()
  7849  func (_SeigToken *SeigTokenSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
  7850  	return _SeigToken.Contract.TransferOwnership(&_SeigToken.TransactOpts, target, newOwner)
  7851  }
  7852  
  7853  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
  7854  //
  7855  // Solidity: function transferOwnership(address target, address newOwner) returns()
  7856  func (_SeigToken *SeigTokenTransactorSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
  7857  	return _SeigToken.Contract.TransferOwnership(&_SeigToken.TransactOpts, target, newOwner)
  7858  }
  7859  
  7860  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
  7861  //
  7862  // Solidity: function transferOwnership(address newOwner) returns()
  7863  func (_SeigToken *SeigTokenTransactor) TransferOwnership0(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
  7864  	return _SeigToken.contract.Transact(opts, "transferOwnership0", newOwner)
  7865  }
  7866  
  7867  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
  7868  //
  7869  // Solidity: function transferOwnership(address newOwner) returns()
  7870  func (_SeigToken *SeigTokenSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
  7871  	return _SeigToken.Contract.TransferOwnership0(&_SeigToken.TransactOpts, newOwner)
  7872  }
  7873  
  7874  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
  7875  //
  7876  // Solidity: function transferOwnership(address newOwner) returns()
  7877  func (_SeigToken *SeigTokenTransactorSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
  7878  	return _SeigToken.Contract.TransferOwnership0(&_SeigToken.TransactOpts, newOwner)
  7879  }
  7880  
  7881  // SeigTokenApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the SeigToken contract.
  7882  type SeigTokenApprovalIterator struct {
  7883  	Event *SeigTokenApproval // Event containing the contract specifics and raw log
  7884  
  7885  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  7886  	event    string              // Event name to use for unpacking event data
  7887  
  7888  	logs chan types.Log        // Log channel receiving the found contract events
  7889  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  7890  	done bool                  // Whether the subscription completed delivering logs
  7891  	fail error                 // Occurred error to stop iteration
  7892  }
  7893  
  7894  // Next advances the iterator to the subsequent event, returning whether there
  7895  // are any more events found. In case of a retrieval or parsing error, false is
  7896  // returned and Error() can be queried for the exact failure.
  7897  func (it *SeigTokenApprovalIterator) Next() bool {
  7898  	// If the iterator failed, stop iterating
  7899  	if it.fail != nil {
  7900  		return false
  7901  	}
  7902  	// If the iterator completed, deliver directly whatever's available
  7903  	if it.done {
  7904  		select {
  7905  		case log := <-it.logs:
  7906  			it.Event = new(SeigTokenApproval)
  7907  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  7908  				it.fail = err
  7909  				return false
  7910  			}
  7911  			it.Event.Raw = log
  7912  			return true
  7913  
  7914  		default:
  7915  			return false
  7916  		}
  7917  	}
  7918  	// Iterator still in progress, wait for either a data or an error event
  7919  	select {
  7920  	case log := <-it.logs:
  7921  		it.Event = new(SeigTokenApproval)
  7922  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  7923  			it.fail = err
  7924  			return false
  7925  		}
  7926  		it.Event.Raw = log
  7927  		return true
  7928  
  7929  	case err := <-it.sub.Err():
  7930  		it.done = true
  7931  		it.fail = err
  7932  		return it.Next()
  7933  	}
  7934  }
  7935  
  7936  // Error returns any retrieval or parsing error occurred during filtering.
  7937  func (it *SeigTokenApprovalIterator) Error() error {
  7938  	return it.fail
  7939  }
  7940  
  7941  // Close terminates the iteration process, releasing any pending underlying
  7942  // resources.
  7943  func (it *SeigTokenApprovalIterator) Close() error {
  7944  	it.sub.Unsubscribe()
  7945  	return nil
  7946  }
  7947  
  7948  // SeigTokenApproval represents a Approval event raised by the SeigToken contract.
  7949  type SeigTokenApproval struct {
  7950  	Owner   common.Address
  7951  	Spender common.Address
  7952  	Value   *big.Int
  7953  	Raw     types.Log // Blockchain specific contextual infos
  7954  }
  7955  
  7956  // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  7957  //
  7958  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  7959  func (_SeigToken *SeigTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*SeigTokenApprovalIterator, error) {
  7960  
  7961  	var ownerRule []interface{}
  7962  	for _, ownerItem := range owner {
  7963  		ownerRule = append(ownerRule, ownerItem)
  7964  	}
  7965  	var spenderRule []interface{}
  7966  	for _, spenderItem := range spender {
  7967  		spenderRule = append(spenderRule, spenderItem)
  7968  	}
  7969  
  7970  	logs, sub, err := _SeigToken.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
  7971  	if err != nil {
  7972  		return nil, err
  7973  	}
  7974  	return &SeigTokenApprovalIterator{contract: _SeigToken.contract, event: "Approval", logs: logs, sub: sub}, nil
  7975  }
  7976  
  7977  // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  7978  //
  7979  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  7980  func (_SeigToken *SeigTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *SeigTokenApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
  7981  
  7982  	var ownerRule []interface{}
  7983  	for _, ownerItem := range owner {
  7984  		ownerRule = append(ownerRule, ownerItem)
  7985  	}
  7986  	var spenderRule []interface{}
  7987  	for _, spenderItem := range spender {
  7988  		spenderRule = append(spenderRule, spenderItem)
  7989  	}
  7990  
  7991  	logs, sub, err := _SeigToken.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
  7992  	if err != nil {
  7993  		return nil, err
  7994  	}
  7995  	return event.NewSubscription(func(quit <-chan struct{}) error {
  7996  		defer sub.Unsubscribe()
  7997  		for {
  7998  			select {
  7999  			case log := <-logs:
  8000  				// New log arrived, parse the event and forward to the user
  8001  				event := new(SeigTokenApproval)
  8002  				if err := _SeigToken.contract.UnpackLog(event, "Approval", log); err != nil {
  8003  					return err
  8004  				}
  8005  				event.Raw = log
  8006  
  8007  				select {
  8008  				case sink <- event:
  8009  				case err := <-sub.Err():
  8010  					return err
  8011  				case <-quit:
  8012  					return nil
  8013  				}
  8014  			case err := <-sub.Err():
  8015  				return err
  8016  			case <-quit:
  8017  				return nil
  8018  			}
  8019  		}
  8020  	}), nil
  8021  }
  8022  
  8023  // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  8024  //
  8025  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  8026  func (_SeigToken *SeigTokenFilterer) ParseApproval(log types.Log) (*SeigTokenApproval, error) {
  8027  	event := new(SeigTokenApproval)
  8028  	if err := _SeigToken.contract.UnpackLog(event, "Approval", log); err != nil {
  8029  		return nil, err
  8030  	}
  8031  	return event, nil
  8032  }
  8033  
  8034  // SeigTokenOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the SeigToken contract.
  8035  type SeigTokenOwnershipTransferredIterator struct {
  8036  	Event *SeigTokenOwnershipTransferred // Event containing the contract specifics and raw log
  8037  
  8038  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  8039  	event    string              // Event name to use for unpacking event data
  8040  
  8041  	logs chan types.Log        // Log channel receiving the found contract events
  8042  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  8043  	done bool                  // Whether the subscription completed delivering logs
  8044  	fail error                 // Occurred error to stop iteration
  8045  }
  8046  
  8047  // Next advances the iterator to the subsequent event, returning whether there
  8048  // are any more events found. In case of a retrieval or parsing error, false is
  8049  // returned and Error() can be queried for the exact failure.
  8050  func (it *SeigTokenOwnershipTransferredIterator) Next() bool {
  8051  	// If the iterator failed, stop iterating
  8052  	if it.fail != nil {
  8053  		return false
  8054  	}
  8055  	// If the iterator completed, deliver directly whatever's available
  8056  	if it.done {
  8057  		select {
  8058  		case log := <-it.logs:
  8059  			it.Event = new(SeigTokenOwnershipTransferred)
  8060  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  8061  				it.fail = err
  8062  				return false
  8063  			}
  8064  			it.Event.Raw = log
  8065  			return true
  8066  
  8067  		default:
  8068  			return false
  8069  		}
  8070  	}
  8071  	// Iterator still in progress, wait for either a data or an error event
  8072  	select {
  8073  	case log := <-it.logs:
  8074  		it.Event = new(SeigTokenOwnershipTransferred)
  8075  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  8076  			it.fail = err
  8077  			return false
  8078  		}
  8079  		it.Event.Raw = log
  8080  		return true
  8081  
  8082  	case err := <-it.sub.Err():
  8083  		it.done = true
  8084  		it.fail = err
  8085  		return it.Next()
  8086  	}
  8087  }
  8088  
  8089  // Error returns any retrieval or parsing error occurred during filtering.
  8090  func (it *SeigTokenOwnershipTransferredIterator) Error() error {
  8091  	return it.fail
  8092  }
  8093  
  8094  // Close terminates the iteration process, releasing any pending underlying
  8095  // resources.
  8096  func (it *SeigTokenOwnershipTransferredIterator) Close() error {
  8097  	it.sub.Unsubscribe()
  8098  	return nil
  8099  }
  8100  
  8101  // SeigTokenOwnershipTransferred represents a OwnershipTransferred event raised by the SeigToken contract.
  8102  type SeigTokenOwnershipTransferred struct {
  8103  	PreviousOwner common.Address
  8104  	NewOwner      common.Address
  8105  	Raw           types.Log // Blockchain specific contextual infos
  8106  }
  8107  
  8108  // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
  8109  //
  8110  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
  8111  func (_SeigToken *SeigTokenFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*SeigTokenOwnershipTransferredIterator, error) {
  8112  
  8113  	var previousOwnerRule []interface{}
  8114  	for _, previousOwnerItem := range previousOwner {
  8115  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
  8116  	}
  8117  	var newOwnerRule []interface{}
  8118  	for _, newOwnerItem := range newOwner {
  8119  		newOwnerRule = append(newOwnerRule, newOwnerItem)
  8120  	}
  8121  
  8122  	logs, sub, err := _SeigToken.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
  8123  	if err != nil {
  8124  		return nil, err
  8125  	}
  8126  	return &SeigTokenOwnershipTransferredIterator{contract: _SeigToken.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
  8127  }
  8128  
  8129  // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
  8130  //
  8131  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
  8132  func (_SeigToken *SeigTokenFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *SeigTokenOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {
  8133  
  8134  	var previousOwnerRule []interface{}
  8135  	for _, previousOwnerItem := range previousOwner {
  8136  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
  8137  	}
  8138  	var newOwnerRule []interface{}
  8139  	for _, newOwnerItem := range newOwner {
  8140  		newOwnerRule = append(newOwnerRule, newOwnerItem)
  8141  	}
  8142  
  8143  	logs, sub, err := _SeigToken.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
  8144  	if err != nil {
  8145  		return nil, err
  8146  	}
  8147  	return event.NewSubscription(func(quit <-chan struct{}) error {
  8148  		defer sub.Unsubscribe()
  8149  		for {
  8150  			select {
  8151  			case log := <-logs:
  8152  				// New log arrived, parse the event and forward to the user
  8153  				event := new(SeigTokenOwnershipTransferred)
  8154  				if err := _SeigToken.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
  8155  					return err
  8156  				}
  8157  				event.Raw = log
  8158  
  8159  				select {
  8160  				case sink <- event:
  8161  				case err := <-sub.Err():
  8162  					return err
  8163  				case <-quit:
  8164  					return nil
  8165  				}
  8166  			case err := <-sub.Err():
  8167  				return err
  8168  			case <-quit:
  8169  				return nil
  8170  			}
  8171  		}
  8172  	}), nil
  8173  }
  8174  
  8175  // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
  8176  //
  8177  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
  8178  func (_SeigToken *SeigTokenFilterer) ParseOwnershipTransferred(log types.Log) (*SeigTokenOwnershipTransferred, error) {
  8179  	event := new(SeigTokenOwnershipTransferred)
  8180  	if err := _SeigToken.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
  8181  		return nil, err
  8182  	}
  8183  	return event, nil
  8184  }
  8185  
  8186  // SeigTokenTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the SeigToken contract.
  8187  type SeigTokenTransferIterator struct {
  8188  	Event *SeigTokenTransfer // Event containing the contract specifics and raw log
  8189  
  8190  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  8191  	event    string              // Event name to use for unpacking event data
  8192  
  8193  	logs chan types.Log        // Log channel receiving the found contract events
  8194  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  8195  	done bool                  // Whether the subscription completed delivering logs
  8196  	fail error                 // Occurred error to stop iteration
  8197  }
  8198  
  8199  // Next advances the iterator to the subsequent event, returning whether there
  8200  // are any more events found. In case of a retrieval or parsing error, false is
  8201  // returned and Error() can be queried for the exact failure.
  8202  func (it *SeigTokenTransferIterator) Next() bool {
  8203  	// If the iterator failed, stop iterating
  8204  	if it.fail != nil {
  8205  		return false
  8206  	}
  8207  	// If the iterator completed, deliver directly whatever's available
  8208  	if it.done {
  8209  		select {
  8210  		case log := <-it.logs:
  8211  			it.Event = new(SeigTokenTransfer)
  8212  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  8213  				it.fail = err
  8214  				return false
  8215  			}
  8216  			it.Event.Raw = log
  8217  			return true
  8218  
  8219  		default:
  8220  			return false
  8221  		}
  8222  	}
  8223  	// Iterator still in progress, wait for either a data or an error event
  8224  	select {
  8225  	case log := <-it.logs:
  8226  		it.Event = new(SeigTokenTransfer)
  8227  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  8228  			it.fail = err
  8229  			return false
  8230  		}
  8231  		it.Event.Raw = log
  8232  		return true
  8233  
  8234  	case err := <-it.sub.Err():
  8235  		it.done = true
  8236  		it.fail = err
  8237  		return it.Next()
  8238  	}
  8239  }
  8240  
  8241  // Error returns any retrieval or parsing error occurred during filtering.
  8242  func (it *SeigTokenTransferIterator) Error() error {
  8243  	return it.fail
  8244  }
  8245  
  8246  // Close terminates the iteration process, releasing any pending underlying
  8247  // resources.
  8248  func (it *SeigTokenTransferIterator) Close() error {
  8249  	it.sub.Unsubscribe()
  8250  	return nil
  8251  }
  8252  
  8253  // SeigTokenTransfer represents a Transfer event raised by the SeigToken contract.
  8254  type SeigTokenTransfer struct {
  8255  	From  common.Address
  8256  	To    common.Address
  8257  	Value *big.Int
  8258  	Raw   types.Log // Blockchain specific contextual infos
  8259  }
  8260  
  8261  // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  8262  //
  8263  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  8264  func (_SeigToken *SeigTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*SeigTokenTransferIterator, error) {
  8265  
  8266  	var fromRule []interface{}
  8267  	for _, fromItem := range from {
  8268  		fromRule = append(fromRule, fromItem)
  8269  	}
  8270  	var toRule []interface{}
  8271  	for _, toItem := range to {
  8272  		toRule = append(toRule, toItem)
  8273  	}
  8274  
  8275  	logs, sub, err := _SeigToken.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
  8276  	if err != nil {
  8277  		return nil, err
  8278  	}
  8279  	return &SeigTokenTransferIterator{contract: _SeigToken.contract, event: "Transfer", logs: logs, sub: sub}, nil
  8280  }
  8281  
  8282  // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  8283  //
  8284  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  8285  func (_SeigToken *SeigTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *SeigTokenTransfer, from []common.Address, to []common.Address) (event.Subscription, error) {
  8286  
  8287  	var fromRule []interface{}
  8288  	for _, fromItem := range from {
  8289  		fromRule = append(fromRule, fromItem)
  8290  	}
  8291  	var toRule []interface{}
  8292  	for _, toItem := range to {
  8293  		toRule = append(toRule, toItem)
  8294  	}
  8295  
  8296  	logs, sub, err := _SeigToken.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
  8297  	if err != nil {
  8298  		return nil, err
  8299  	}
  8300  	return event.NewSubscription(func(quit <-chan struct{}) error {
  8301  		defer sub.Unsubscribe()
  8302  		for {
  8303  			select {
  8304  			case log := <-logs:
  8305  				// New log arrived, parse the event and forward to the user
  8306  				event := new(SeigTokenTransfer)
  8307  				if err := _SeigToken.contract.UnpackLog(event, "Transfer", log); err != nil {
  8308  					return err
  8309  				}
  8310  				event.Raw = log
  8311  
  8312  				select {
  8313  				case sink <- event:
  8314  				case err := <-sub.Err():
  8315  					return err
  8316  				case <-quit:
  8317  					return nil
  8318  				}
  8319  			case err := <-sub.Err():
  8320  				return err
  8321  			case <-quit:
  8322  				return nil
  8323  			}
  8324  		}
  8325  	}), nil
  8326  }
  8327  
  8328  // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  8329  //
  8330  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  8331  func (_SeigToken *SeigTokenFilterer) ParseTransfer(log types.Log) (*SeigTokenTransfer, error) {
  8332  	event := new(SeigTokenTransfer)
  8333  	if err := _SeigToken.contract.UnpackLog(event, "Transfer", log); err != nil {
  8334  		return nil, err
  8335  	}
  8336  	return event, nil
  8337  }
  8338  
  8339  // TONABI is the input ABI used to generate the binding from.
  8340  const TONABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"INTERFACE_ID_ON_APPROVE\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"approveAndCall\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isMinter\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigManager\",\"outputs\":[{\"internalType\":\"contractSeigManagerI\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"contractSeigManagerI\",\"name\":\"_seigManager\",\"type\":\"address\"}],\"name\":\"setSeigManager\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
  8341  
  8342  // TONFuncSigs maps the 4-byte function signature to its string representation.
  8343  var TONFuncSigs = map[string]string{
  8344  	"6cd28f9a": "INTERFACE_ID_ON_APPROVE()",
  8345  	"983b2d56": "addMinter(address)",
  8346  	"dd62ed3e": "allowance(address,address)",
  8347  	"095ea7b3": "approve(address,uint256)",
  8348  	"cae9ca51": "approveAndCall(address,uint256,bytes)",
  8349  	"70a08231": "balanceOf(address)",
  8350  	"313ce567": "decimals()",
  8351  	"a457c2d7": "decreaseAllowance(address,uint256)",
  8352  	"39509351": "increaseAllowance(address,uint256)",
  8353  	"aa271e1a": "isMinter(address)",
  8354  	"8f32d59b": "isOwner()",
  8355  	"40c10f19": "mint(address,uint256)",
  8356  	"06fdde03": "name()",
  8357  	"8da5cb5b": "owner()",
  8358  	"98650275": "renounceMinter()",
  8359  	"5f112c68": "renounceMinter(address)",
  8360  	"715018a6": "renounceOwnership()",
  8361  	"38bf3cfa": "renounceOwnership(address)",
  8362  	"41eb24bb": "renouncePauser(address)",
  8363  	"6fb7f558": "seigManager()",
  8364  	"7657f20a": "setSeigManager(address)",
  8365  	"95d89b41": "symbol()",
  8366  	"18160ddd": "totalSupply()",
  8367  	"a9059cbb": "transfer(address,uint256)",
  8368  	"23b872dd": "transferFrom(address,address,uint256)",
  8369  	"f2fde38b": "transferOwnership(address)",
  8370  	"6d435421": "transferOwnership(address,address)",
  8371  }
  8372  
  8373  // TONBin is the compiled bytecode used for deploying new contracts.
  8374  var TONBin = "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"
  8375  
  8376  // DeployTON deploys a new Ethereum contract, binding an instance of TON to it.
  8377  func DeployTON(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *TON, error) {
  8378  	parsed, err := abi.JSON(strings.NewReader(TONABI))
  8379  	if err != nil {
  8380  		return common.Address{}, nil, nil, err
  8381  	}
  8382  
  8383  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(TONBin), backend)
  8384  	if err != nil {
  8385  		return common.Address{}, nil, nil, err
  8386  	}
  8387  	return address, tx, &TON{TONCaller: TONCaller{contract: contract}, TONTransactor: TONTransactor{contract: contract}, TONFilterer: TONFilterer{contract: contract}}, nil
  8388  }
  8389  
  8390  // TON is an auto generated Go binding around an Ethereum contract.
  8391  type TON struct {
  8392  	TONCaller     // Read-only binding to the contract
  8393  	TONTransactor // Write-only binding to the contract
  8394  	TONFilterer   // Log filterer for contract events
  8395  }
  8396  
  8397  // TONCaller is an auto generated read-only Go binding around an Ethereum contract.
  8398  type TONCaller struct {
  8399  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  8400  }
  8401  
  8402  // TONTransactor is an auto generated write-only Go binding around an Ethereum contract.
  8403  type TONTransactor struct {
  8404  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  8405  }
  8406  
  8407  // TONFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  8408  type TONFilterer struct {
  8409  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  8410  }
  8411  
  8412  // TONSession is an auto generated Go binding around an Ethereum contract,
  8413  // with pre-set call and transact options.
  8414  type TONSession struct {
  8415  	Contract     *TON              // Generic contract binding to set the session for
  8416  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  8417  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  8418  }
  8419  
  8420  // TONCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  8421  // with pre-set call options.
  8422  type TONCallerSession struct {
  8423  	Contract *TONCaller    // Generic contract caller binding to set the session for
  8424  	CallOpts bind.CallOpts // Call options to use throughout this session
  8425  }
  8426  
  8427  // TONTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  8428  // with pre-set transact options.
  8429  type TONTransactorSession struct {
  8430  	Contract     *TONTransactor    // Generic contract transactor binding to set the session for
  8431  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  8432  }
  8433  
  8434  // TONRaw is an auto generated low-level Go binding around an Ethereum contract.
  8435  type TONRaw struct {
  8436  	Contract *TON // Generic contract binding to access the raw methods on
  8437  }
  8438  
  8439  // TONCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  8440  type TONCallerRaw struct {
  8441  	Contract *TONCaller // Generic read-only contract binding to access the raw methods on
  8442  }
  8443  
  8444  // TONTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  8445  type TONTransactorRaw struct {
  8446  	Contract *TONTransactor // Generic write-only contract binding to access the raw methods on
  8447  }
  8448  
  8449  // NewTON creates a new instance of TON, bound to a specific deployed contract.
  8450  func NewTON(address common.Address, backend bind.ContractBackend) (*TON, error) {
  8451  	contract, err := bindTON(address, backend, backend, backend)
  8452  	if err != nil {
  8453  		return nil, err
  8454  	}
  8455  	return &TON{TONCaller: TONCaller{contract: contract}, TONTransactor: TONTransactor{contract: contract}, TONFilterer: TONFilterer{contract: contract}}, nil
  8456  }
  8457  
  8458  // NewTONCaller creates a new read-only instance of TON, bound to a specific deployed contract.
  8459  func NewTONCaller(address common.Address, caller bind.ContractCaller) (*TONCaller, error) {
  8460  	contract, err := bindTON(address, caller, nil, nil)
  8461  	if err != nil {
  8462  		return nil, err
  8463  	}
  8464  	return &TONCaller{contract: contract}, nil
  8465  }
  8466  
  8467  // NewTONTransactor creates a new write-only instance of TON, bound to a specific deployed contract.
  8468  func NewTONTransactor(address common.Address, transactor bind.ContractTransactor) (*TONTransactor, error) {
  8469  	contract, err := bindTON(address, nil, transactor, nil)
  8470  	if err != nil {
  8471  		return nil, err
  8472  	}
  8473  	return &TONTransactor{contract: contract}, nil
  8474  }
  8475  
  8476  // NewTONFilterer creates a new log filterer instance of TON, bound to a specific deployed contract.
  8477  func NewTONFilterer(address common.Address, filterer bind.ContractFilterer) (*TONFilterer, error) {
  8478  	contract, err := bindTON(address, nil, nil, filterer)
  8479  	if err != nil {
  8480  		return nil, err
  8481  	}
  8482  	return &TONFilterer{contract: contract}, nil
  8483  }
  8484  
  8485  // bindTON binds a generic wrapper to an already deployed contract.
  8486  func bindTON(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  8487  	parsed, err := abi.JSON(strings.NewReader(TONABI))
  8488  	if err != nil {
  8489  		return nil, err
  8490  	}
  8491  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  8492  }
  8493  
  8494  // Call invokes the (constant) contract method with params as input values and
  8495  // sets the output to result. The result type might be a single field for simple
  8496  // returns, a slice of interfaces for anonymous returns and a struct for named
  8497  // returns.
  8498  func (_TON *TONRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  8499  	return _TON.Contract.TONCaller.contract.Call(opts, result, method, params...)
  8500  }
  8501  
  8502  // Transfer initiates a plain transaction to move funds to the contract, calling
  8503  // its default method if one is available.
  8504  func (_TON *TONRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  8505  	return _TON.Contract.TONTransactor.contract.Transfer(opts)
  8506  }
  8507  
  8508  // Transact invokes the (paid) contract method with params as input values.
  8509  func (_TON *TONRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  8510  	return _TON.Contract.TONTransactor.contract.Transact(opts, method, params...)
  8511  }
  8512  
  8513  // Call invokes the (constant) contract method with params as input values and
  8514  // sets the output to result. The result type might be a single field for simple
  8515  // returns, a slice of interfaces for anonymous returns and a struct for named
  8516  // returns.
  8517  func (_TON *TONCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  8518  	return _TON.Contract.contract.Call(opts, result, method, params...)
  8519  }
  8520  
  8521  // Transfer initiates a plain transaction to move funds to the contract, calling
  8522  // its default method if one is available.
  8523  func (_TON *TONTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  8524  	return _TON.Contract.contract.Transfer(opts)
  8525  }
  8526  
  8527  // Transact invokes the (paid) contract method with params as input values.
  8528  func (_TON *TONTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  8529  	return _TON.Contract.contract.Transact(opts, method, params...)
  8530  }
  8531  
  8532  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  8533  //
  8534  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  8535  func (_TON *TONCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) {
  8536  	var (
  8537  		ret0 = new([4]byte)
  8538  	)
  8539  	out := ret0
  8540  	err := _TON.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE")
  8541  	return *ret0, err
  8542  }
  8543  
  8544  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  8545  //
  8546  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  8547  func (_TON *TONSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  8548  	return _TON.Contract.INTERFACEIDONAPPROVE(&_TON.CallOpts)
  8549  }
  8550  
  8551  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  8552  //
  8553  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  8554  func (_TON *TONCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  8555  	return _TON.Contract.INTERFACEIDONAPPROVE(&_TON.CallOpts)
  8556  }
  8557  
  8558  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  8559  //
  8560  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  8561  func (_TON *TONCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
  8562  	var (
  8563  		ret0 = new(*big.Int)
  8564  	)
  8565  	out := ret0
  8566  	err := _TON.contract.Call(opts, out, "allowance", owner, spender)
  8567  	return *ret0, err
  8568  }
  8569  
  8570  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  8571  //
  8572  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  8573  func (_TON *TONSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  8574  	return _TON.Contract.Allowance(&_TON.CallOpts, owner, spender)
  8575  }
  8576  
  8577  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  8578  //
  8579  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  8580  func (_TON *TONCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  8581  	return _TON.Contract.Allowance(&_TON.CallOpts, owner, spender)
  8582  }
  8583  
  8584  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  8585  //
  8586  // Solidity: function balanceOf(address account) constant returns(uint256)
  8587  func (_TON *TONCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  8588  	var (
  8589  		ret0 = new(*big.Int)
  8590  	)
  8591  	out := ret0
  8592  	err := _TON.contract.Call(opts, out, "balanceOf", account)
  8593  	return *ret0, err
  8594  }
  8595  
  8596  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  8597  //
  8598  // Solidity: function balanceOf(address account) constant returns(uint256)
  8599  func (_TON *TONSession) BalanceOf(account common.Address) (*big.Int, error) {
  8600  	return _TON.Contract.BalanceOf(&_TON.CallOpts, account)
  8601  }
  8602  
  8603  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  8604  //
  8605  // Solidity: function balanceOf(address account) constant returns(uint256)
  8606  func (_TON *TONCallerSession) BalanceOf(account common.Address) (*big.Int, error) {
  8607  	return _TON.Contract.BalanceOf(&_TON.CallOpts, account)
  8608  }
  8609  
  8610  // Decimals is a free data retrieval call binding the contract method 0x313ce567.
  8611  //
  8612  // Solidity: function decimals() constant returns(uint8)
  8613  func (_TON *TONCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
  8614  	var (
  8615  		ret0 = new(uint8)
  8616  	)
  8617  	out := ret0
  8618  	err := _TON.contract.Call(opts, out, "decimals")
  8619  	return *ret0, err
  8620  }
  8621  
  8622  // Decimals is a free data retrieval call binding the contract method 0x313ce567.
  8623  //
  8624  // Solidity: function decimals() constant returns(uint8)
  8625  func (_TON *TONSession) Decimals() (uint8, error) {
  8626  	return _TON.Contract.Decimals(&_TON.CallOpts)
  8627  }
  8628  
  8629  // Decimals is a free data retrieval call binding the contract method 0x313ce567.
  8630  //
  8631  // Solidity: function decimals() constant returns(uint8)
  8632  func (_TON *TONCallerSession) Decimals() (uint8, error) {
  8633  	return _TON.Contract.Decimals(&_TON.CallOpts)
  8634  }
  8635  
  8636  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
  8637  //
  8638  // Solidity: function isMinter(address account) constant returns(bool)
  8639  func (_TON *TONCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) {
  8640  	var (
  8641  		ret0 = new(bool)
  8642  	)
  8643  	out := ret0
  8644  	err := _TON.contract.Call(opts, out, "isMinter", account)
  8645  	return *ret0, err
  8646  }
  8647  
  8648  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
  8649  //
  8650  // Solidity: function isMinter(address account) constant returns(bool)
  8651  func (_TON *TONSession) IsMinter(account common.Address) (bool, error) {
  8652  	return _TON.Contract.IsMinter(&_TON.CallOpts, account)
  8653  }
  8654  
  8655  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
  8656  //
  8657  // Solidity: function isMinter(address account) constant returns(bool)
  8658  func (_TON *TONCallerSession) IsMinter(account common.Address) (bool, error) {
  8659  	return _TON.Contract.IsMinter(&_TON.CallOpts, account)
  8660  }
  8661  
  8662  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
  8663  //
  8664  // Solidity: function isOwner() constant returns(bool)
  8665  func (_TON *TONCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
  8666  	var (
  8667  		ret0 = new(bool)
  8668  	)
  8669  	out := ret0
  8670  	err := _TON.contract.Call(opts, out, "isOwner")
  8671  	return *ret0, err
  8672  }
  8673  
  8674  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
  8675  //
  8676  // Solidity: function isOwner() constant returns(bool)
  8677  func (_TON *TONSession) IsOwner() (bool, error) {
  8678  	return _TON.Contract.IsOwner(&_TON.CallOpts)
  8679  }
  8680  
  8681  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
  8682  //
  8683  // Solidity: function isOwner() constant returns(bool)
  8684  func (_TON *TONCallerSession) IsOwner() (bool, error) {
  8685  	return _TON.Contract.IsOwner(&_TON.CallOpts)
  8686  }
  8687  
  8688  // Name is a free data retrieval call binding the contract method 0x06fdde03.
  8689  //
  8690  // Solidity: function name() constant returns(string)
  8691  func (_TON *TONCaller) Name(opts *bind.CallOpts) (string, error) {
  8692  	var (
  8693  		ret0 = new(string)
  8694  	)
  8695  	out := ret0
  8696  	err := _TON.contract.Call(opts, out, "name")
  8697  	return *ret0, err
  8698  }
  8699  
  8700  // Name is a free data retrieval call binding the contract method 0x06fdde03.
  8701  //
  8702  // Solidity: function name() constant returns(string)
  8703  func (_TON *TONSession) Name() (string, error) {
  8704  	return _TON.Contract.Name(&_TON.CallOpts)
  8705  }
  8706  
  8707  // Name is a free data retrieval call binding the contract method 0x06fdde03.
  8708  //
  8709  // Solidity: function name() constant returns(string)
  8710  func (_TON *TONCallerSession) Name() (string, error) {
  8711  	return _TON.Contract.Name(&_TON.CallOpts)
  8712  }
  8713  
  8714  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  8715  //
  8716  // Solidity: function owner() constant returns(address)
  8717  func (_TON *TONCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
  8718  	var (
  8719  		ret0 = new(common.Address)
  8720  	)
  8721  	out := ret0
  8722  	err := _TON.contract.Call(opts, out, "owner")
  8723  	return *ret0, err
  8724  }
  8725  
  8726  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  8727  //
  8728  // Solidity: function owner() constant returns(address)
  8729  func (_TON *TONSession) Owner() (common.Address, error) {
  8730  	return _TON.Contract.Owner(&_TON.CallOpts)
  8731  }
  8732  
  8733  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  8734  //
  8735  // Solidity: function owner() constant returns(address)
  8736  func (_TON *TONCallerSession) Owner() (common.Address, error) {
  8737  	return _TON.Contract.Owner(&_TON.CallOpts)
  8738  }
  8739  
  8740  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
  8741  //
  8742  // Solidity: function seigManager() constant returns(address)
  8743  func (_TON *TONCaller) SeigManager(opts *bind.CallOpts) (common.Address, error) {
  8744  	var (
  8745  		ret0 = new(common.Address)
  8746  	)
  8747  	out := ret0
  8748  	err := _TON.contract.Call(opts, out, "seigManager")
  8749  	return *ret0, err
  8750  }
  8751  
  8752  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
  8753  //
  8754  // Solidity: function seigManager() constant returns(address)
  8755  func (_TON *TONSession) SeigManager() (common.Address, error) {
  8756  	return _TON.Contract.SeigManager(&_TON.CallOpts)
  8757  }
  8758  
  8759  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
  8760  //
  8761  // Solidity: function seigManager() constant returns(address)
  8762  func (_TON *TONCallerSession) SeigManager() (common.Address, error) {
  8763  	return _TON.Contract.SeigManager(&_TON.CallOpts)
  8764  }
  8765  
  8766  // Symbol is a free data retrieval call binding the contract method 0x95d89b41.
  8767  //
  8768  // Solidity: function symbol() constant returns(string)
  8769  func (_TON *TONCaller) Symbol(opts *bind.CallOpts) (string, error) {
  8770  	var (
  8771  		ret0 = new(string)
  8772  	)
  8773  	out := ret0
  8774  	err := _TON.contract.Call(opts, out, "symbol")
  8775  	return *ret0, err
  8776  }
  8777  
  8778  // Symbol is a free data retrieval call binding the contract method 0x95d89b41.
  8779  //
  8780  // Solidity: function symbol() constant returns(string)
  8781  func (_TON *TONSession) Symbol() (string, error) {
  8782  	return _TON.Contract.Symbol(&_TON.CallOpts)
  8783  }
  8784  
  8785  // Symbol is a free data retrieval call binding the contract method 0x95d89b41.
  8786  //
  8787  // Solidity: function symbol() constant returns(string)
  8788  func (_TON *TONCallerSession) Symbol() (string, error) {
  8789  	return _TON.Contract.Symbol(&_TON.CallOpts)
  8790  }
  8791  
  8792  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  8793  //
  8794  // Solidity: function totalSupply() constant returns(uint256)
  8795  func (_TON *TONCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
  8796  	var (
  8797  		ret0 = new(*big.Int)
  8798  	)
  8799  	out := ret0
  8800  	err := _TON.contract.Call(opts, out, "totalSupply")
  8801  	return *ret0, err
  8802  }
  8803  
  8804  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  8805  //
  8806  // Solidity: function totalSupply() constant returns(uint256)
  8807  func (_TON *TONSession) TotalSupply() (*big.Int, error) {
  8808  	return _TON.Contract.TotalSupply(&_TON.CallOpts)
  8809  }
  8810  
  8811  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  8812  //
  8813  // Solidity: function totalSupply() constant returns(uint256)
  8814  func (_TON *TONCallerSession) TotalSupply() (*big.Int, error) {
  8815  	return _TON.Contract.TotalSupply(&_TON.CallOpts)
  8816  }
  8817  
  8818  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
  8819  //
  8820  // Solidity: function addMinter(address account) returns()
  8821  func (_TON *TONTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
  8822  	return _TON.contract.Transact(opts, "addMinter", account)
  8823  }
  8824  
  8825  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
  8826  //
  8827  // Solidity: function addMinter(address account) returns()
  8828  func (_TON *TONSession) AddMinter(account common.Address) (*types.Transaction, error) {
  8829  	return _TON.Contract.AddMinter(&_TON.TransactOpts, account)
  8830  }
  8831  
  8832  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
  8833  //
  8834  // Solidity: function addMinter(address account) returns()
  8835  func (_TON *TONTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) {
  8836  	return _TON.Contract.AddMinter(&_TON.TransactOpts, account)
  8837  }
  8838  
  8839  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  8840  //
  8841  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  8842  func (_TON *TONTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
  8843  	return _TON.contract.Transact(opts, "approve", spender, amount)
  8844  }
  8845  
  8846  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  8847  //
  8848  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  8849  func (_TON *TONSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  8850  	return _TON.Contract.Approve(&_TON.TransactOpts, spender, amount)
  8851  }
  8852  
  8853  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  8854  //
  8855  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  8856  func (_TON *TONTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  8857  	return _TON.Contract.Approve(&_TON.TransactOpts, spender, amount)
  8858  }
  8859  
  8860  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
  8861  //
  8862  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
  8863  func (_TON *TONTransactor) ApproveAndCall(opts *bind.TransactOpts, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  8864  	return _TON.contract.Transact(opts, "approveAndCall", spender, amount, data)
  8865  }
  8866  
  8867  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
  8868  //
  8869  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
  8870  func (_TON *TONSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  8871  	return _TON.Contract.ApproveAndCall(&_TON.TransactOpts, spender, amount, data)
  8872  }
  8873  
  8874  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
  8875  //
  8876  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
  8877  func (_TON *TONTransactorSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  8878  	return _TON.Contract.ApproveAndCall(&_TON.TransactOpts, spender, amount, data)
  8879  }
  8880  
  8881  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  8882  //
  8883  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  8884  func (_TON *TONTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  8885  	return _TON.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
  8886  }
  8887  
  8888  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  8889  //
  8890  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  8891  func (_TON *TONSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  8892  	return _TON.Contract.DecreaseAllowance(&_TON.TransactOpts, spender, subtractedValue)
  8893  }
  8894  
  8895  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  8896  //
  8897  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  8898  func (_TON *TONTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  8899  	return _TON.Contract.DecreaseAllowance(&_TON.TransactOpts, spender, subtractedValue)
  8900  }
  8901  
  8902  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  8903  //
  8904  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  8905  func (_TON *TONTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  8906  	return _TON.contract.Transact(opts, "increaseAllowance", spender, addedValue)
  8907  }
  8908  
  8909  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  8910  //
  8911  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  8912  func (_TON *TONSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  8913  	return _TON.Contract.IncreaseAllowance(&_TON.TransactOpts, spender, addedValue)
  8914  }
  8915  
  8916  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  8917  //
  8918  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  8919  func (_TON *TONTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  8920  	return _TON.Contract.IncreaseAllowance(&_TON.TransactOpts, spender, addedValue)
  8921  }
  8922  
  8923  // Mint is a paid mutator transaction binding the contract method 0x40c10f19.
  8924  //
  8925  // Solidity: function mint(address account, uint256 amount) returns(bool)
  8926  func (_TON *TONTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) {
  8927  	return _TON.contract.Transact(opts, "mint", account, amount)
  8928  }
  8929  
  8930  // Mint is a paid mutator transaction binding the contract method 0x40c10f19.
  8931  //
  8932  // Solidity: function mint(address account, uint256 amount) returns(bool)
  8933  func (_TON *TONSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
  8934  	return _TON.Contract.Mint(&_TON.TransactOpts, account, amount)
  8935  }
  8936  
  8937  // Mint is a paid mutator transaction binding the contract method 0x40c10f19.
  8938  //
  8939  // Solidity: function mint(address account, uint256 amount) returns(bool)
  8940  func (_TON *TONTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
  8941  	return _TON.Contract.Mint(&_TON.TransactOpts, account, amount)
  8942  }
  8943  
  8944  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
  8945  //
  8946  // Solidity: function renounceMinter(address target) returns()
  8947  func (_TON *TONTransactor) RenounceMinter(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
  8948  	return _TON.contract.Transact(opts, "renounceMinter", target)
  8949  }
  8950  
  8951  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
  8952  //
  8953  // Solidity: function renounceMinter(address target) returns()
  8954  func (_TON *TONSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
  8955  	return _TON.Contract.RenounceMinter(&_TON.TransactOpts, target)
  8956  }
  8957  
  8958  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
  8959  //
  8960  // Solidity: function renounceMinter(address target) returns()
  8961  func (_TON *TONTransactorSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
  8962  	return _TON.Contract.RenounceMinter(&_TON.TransactOpts, target)
  8963  }
  8964  
  8965  // RenounceMinter0 is a paid mutator transaction binding the contract method 0x98650275.
  8966  //
  8967  // Solidity: function renounceMinter() returns()
  8968  func (_TON *TONTransactor) RenounceMinter0(opts *bind.TransactOpts) (*types.Transaction, error) {
  8969  	return _TON.contract.Transact(opts, "renounceMinter0")
  8970  }
  8971  
  8972  // RenounceMinter0 is a paid mutator transaction binding the contract method 0x98650275.
  8973  //
  8974  // Solidity: function renounceMinter() returns()
  8975  func (_TON *TONSession) RenounceMinter0() (*types.Transaction, error) {
  8976  	return _TON.Contract.RenounceMinter0(&_TON.TransactOpts)
  8977  }
  8978  
  8979  // RenounceMinter0 is a paid mutator transaction binding the contract method 0x98650275.
  8980  //
  8981  // Solidity: function renounceMinter() returns()
  8982  func (_TON *TONTransactorSession) RenounceMinter0() (*types.Transaction, error) {
  8983  	return _TON.Contract.RenounceMinter0(&_TON.TransactOpts)
  8984  }
  8985  
  8986  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
  8987  //
  8988  // Solidity: function renounceOwnership(address target) returns()
  8989  func (_TON *TONTransactor) RenounceOwnership(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
  8990  	return _TON.contract.Transact(opts, "renounceOwnership", target)
  8991  }
  8992  
  8993  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
  8994  //
  8995  // Solidity: function renounceOwnership(address target) returns()
  8996  func (_TON *TONSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
  8997  	return _TON.Contract.RenounceOwnership(&_TON.TransactOpts, target)
  8998  }
  8999  
  9000  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
  9001  //
  9002  // Solidity: function renounceOwnership(address target) returns()
  9003  func (_TON *TONTransactorSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
  9004  	return _TON.Contract.RenounceOwnership(&_TON.TransactOpts, target)
  9005  }
  9006  
  9007  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
  9008  //
  9009  // Solidity: function renounceOwnership() returns()
  9010  func (_TON *TONTransactor) RenounceOwnership0(opts *bind.TransactOpts) (*types.Transaction, error) {
  9011  	return _TON.contract.Transact(opts, "renounceOwnership0")
  9012  }
  9013  
  9014  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
  9015  //
  9016  // Solidity: function renounceOwnership() returns()
  9017  func (_TON *TONSession) RenounceOwnership0() (*types.Transaction, error) {
  9018  	return _TON.Contract.RenounceOwnership0(&_TON.TransactOpts)
  9019  }
  9020  
  9021  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
  9022  //
  9023  // Solidity: function renounceOwnership() returns()
  9024  func (_TON *TONTransactorSession) RenounceOwnership0() (*types.Transaction, error) {
  9025  	return _TON.Contract.RenounceOwnership0(&_TON.TransactOpts)
  9026  }
  9027  
  9028  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
  9029  //
  9030  // Solidity: function renouncePauser(address target) returns()
  9031  func (_TON *TONTransactor) RenouncePauser(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
  9032  	return _TON.contract.Transact(opts, "renouncePauser", target)
  9033  }
  9034  
  9035  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
  9036  //
  9037  // Solidity: function renouncePauser(address target) returns()
  9038  func (_TON *TONSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
  9039  	return _TON.Contract.RenouncePauser(&_TON.TransactOpts, target)
  9040  }
  9041  
  9042  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
  9043  //
  9044  // Solidity: function renouncePauser(address target) returns()
  9045  func (_TON *TONTransactorSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
  9046  	return _TON.Contract.RenouncePauser(&_TON.TransactOpts, target)
  9047  }
  9048  
  9049  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
  9050  //
  9051  // Solidity: function setSeigManager(address _seigManager) returns()
  9052  func (_TON *TONTransactor) SetSeigManager(opts *bind.TransactOpts, _seigManager common.Address) (*types.Transaction, error) {
  9053  	return _TON.contract.Transact(opts, "setSeigManager", _seigManager)
  9054  }
  9055  
  9056  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
  9057  //
  9058  // Solidity: function setSeigManager(address _seigManager) returns()
  9059  func (_TON *TONSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) {
  9060  	return _TON.Contract.SetSeigManager(&_TON.TransactOpts, _seigManager)
  9061  }
  9062  
  9063  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
  9064  //
  9065  // Solidity: function setSeigManager(address _seigManager) returns()
  9066  func (_TON *TONTransactorSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) {
  9067  	return _TON.Contract.SetSeigManager(&_TON.TransactOpts, _seigManager)
  9068  }
  9069  
  9070  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  9071  //
  9072  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  9073  func (_TON *TONTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  9074  	return _TON.contract.Transact(opts, "transfer", recipient, amount)
  9075  }
  9076  
  9077  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  9078  //
  9079  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  9080  func (_TON *TONSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  9081  	return _TON.Contract.Transfer(&_TON.TransactOpts, recipient, amount)
  9082  }
  9083  
  9084  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  9085  //
  9086  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  9087  func (_TON *TONTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  9088  	return _TON.Contract.Transfer(&_TON.TransactOpts, recipient, amount)
  9089  }
  9090  
  9091  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  9092  //
  9093  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  9094  func (_TON *TONTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  9095  	return _TON.contract.Transact(opts, "transferFrom", sender, recipient, amount)
  9096  }
  9097  
  9098  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  9099  //
  9100  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  9101  func (_TON *TONSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  9102  	return _TON.Contract.TransferFrom(&_TON.TransactOpts, sender, recipient, amount)
  9103  }
  9104  
  9105  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  9106  //
  9107  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  9108  func (_TON *TONTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  9109  	return _TON.Contract.TransferFrom(&_TON.TransactOpts, sender, recipient, amount)
  9110  }
  9111  
  9112  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
  9113  //
  9114  // Solidity: function transferOwnership(address target, address newOwner) returns()
  9115  func (_TON *TONTransactor) TransferOwnership(opts *bind.TransactOpts, target common.Address, newOwner common.Address) (*types.Transaction, error) {
  9116  	return _TON.contract.Transact(opts, "transferOwnership", target, newOwner)
  9117  }
  9118  
  9119  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
  9120  //
  9121  // Solidity: function transferOwnership(address target, address newOwner) returns()
  9122  func (_TON *TONSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
  9123  	return _TON.Contract.TransferOwnership(&_TON.TransactOpts, target, newOwner)
  9124  }
  9125  
  9126  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
  9127  //
  9128  // Solidity: function transferOwnership(address target, address newOwner) returns()
  9129  func (_TON *TONTransactorSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
  9130  	return _TON.Contract.TransferOwnership(&_TON.TransactOpts, target, newOwner)
  9131  }
  9132  
  9133  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
  9134  //
  9135  // Solidity: function transferOwnership(address newOwner) returns()
  9136  func (_TON *TONTransactor) TransferOwnership0(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
  9137  	return _TON.contract.Transact(opts, "transferOwnership0", newOwner)
  9138  }
  9139  
  9140  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
  9141  //
  9142  // Solidity: function transferOwnership(address newOwner) returns()
  9143  func (_TON *TONSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
  9144  	return _TON.Contract.TransferOwnership0(&_TON.TransactOpts, newOwner)
  9145  }
  9146  
  9147  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
  9148  //
  9149  // Solidity: function transferOwnership(address newOwner) returns()
  9150  func (_TON *TONTransactorSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
  9151  	return _TON.Contract.TransferOwnership0(&_TON.TransactOpts, newOwner)
  9152  }
  9153  
  9154  // TONApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the TON contract.
  9155  type TONApprovalIterator struct {
  9156  	Event *TONApproval // Event containing the contract specifics and raw log
  9157  
  9158  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  9159  	event    string              // Event name to use for unpacking event data
  9160  
  9161  	logs chan types.Log        // Log channel receiving the found contract events
  9162  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  9163  	done bool                  // Whether the subscription completed delivering logs
  9164  	fail error                 // Occurred error to stop iteration
  9165  }
  9166  
  9167  // Next advances the iterator to the subsequent event, returning whether there
  9168  // are any more events found. In case of a retrieval or parsing error, false is
  9169  // returned and Error() can be queried for the exact failure.
  9170  func (it *TONApprovalIterator) Next() bool {
  9171  	// If the iterator failed, stop iterating
  9172  	if it.fail != nil {
  9173  		return false
  9174  	}
  9175  	// If the iterator completed, deliver directly whatever's available
  9176  	if it.done {
  9177  		select {
  9178  		case log := <-it.logs:
  9179  			it.Event = new(TONApproval)
  9180  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  9181  				it.fail = err
  9182  				return false
  9183  			}
  9184  			it.Event.Raw = log
  9185  			return true
  9186  
  9187  		default:
  9188  			return false
  9189  		}
  9190  	}
  9191  	// Iterator still in progress, wait for either a data or an error event
  9192  	select {
  9193  	case log := <-it.logs:
  9194  		it.Event = new(TONApproval)
  9195  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  9196  			it.fail = err
  9197  			return false
  9198  		}
  9199  		it.Event.Raw = log
  9200  		return true
  9201  
  9202  	case err := <-it.sub.Err():
  9203  		it.done = true
  9204  		it.fail = err
  9205  		return it.Next()
  9206  	}
  9207  }
  9208  
  9209  // Error returns any retrieval or parsing error occurred during filtering.
  9210  func (it *TONApprovalIterator) Error() error {
  9211  	return it.fail
  9212  }
  9213  
  9214  // Close terminates the iteration process, releasing any pending underlying
  9215  // resources.
  9216  func (it *TONApprovalIterator) Close() error {
  9217  	it.sub.Unsubscribe()
  9218  	return nil
  9219  }
  9220  
  9221  // TONApproval represents a Approval event raised by the TON contract.
  9222  type TONApproval struct {
  9223  	Owner   common.Address
  9224  	Spender common.Address
  9225  	Value   *big.Int
  9226  	Raw     types.Log // Blockchain specific contextual infos
  9227  }
  9228  
  9229  // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  9230  //
  9231  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  9232  func (_TON *TONFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*TONApprovalIterator, error) {
  9233  
  9234  	var ownerRule []interface{}
  9235  	for _, ownerItem := range owner {
  9236  		ownerRule = append(ownerRule, ownerItem)
  9237  	}
  9238  	var spenderRule []interface{}
  9239  	for _, spenderItem := range spender {
  9240  		spenderRule = append(spenderRule, spenderItem)
  9241  	}
  9242  
  9243  	logs, sub, err := _TON.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
  9244  	if err != nil {
  9245  		return nil, err
  9246  	}
  9247  	return &TONApprovalIterator{contract: _TON.contract, event: "Approval", logs: logs, sub: sub}, nil
  9248  }
  9249  
  9250  // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  9251  //
  9252  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  9253  func (_TON *TONFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *TONApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
  9254  
  9255  	var ownerRule []interface{}
  9256  	for _, ownerItem := range owner {
  9257  		ownerRule = append(ownerRule, ownerItem)
  9258  	}
  9259  	var spenderRule []interface{}
  9260  	for _, spenderItem := range spender {
  9261  		spenderRule = append(spenderRule, spenderItem)
  9262  	}
  9263  
  9264  	logs, sub, err := _TON.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
  9265  	if err != nil {
  9266  		return nil, err
  9267  	}
  9268  	return event.NewSubscription(func(quit <-chan struct{}) error {
  9269  		defer sub.Unsubscribe()
  9270  		for {
  9271  			select {
  9272  			case log := <-logs:
  9273  				// New log arrived, parse the event and forward to the user
  9274  				event := new(TONApproval)
  9275  				if err := _TON.contract.UnpackLog(event, "Approval", log); err != nil {
  9276  					return err
  9277  				}
  9278  				event.Raw = log
  9279  
  9280  				select {
  9281  				case sink <- event:
  9282  				case err := <-sub.Err():
  9283  					return err
  9284  				case <-quit:
  9285  					return nil
  9286  				}
  9287  			case err := <-sub.Err():
  9288  				return err
  9289  			case <-quit:
  9290  				return nil
  9291  			}
  9292  		}
  9293  	}), nil
  9294  }
  9295  
  9296  // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  9297  //
  9298  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  9299  func (_TON *TONFilterer) ParseApproval(log types.Log) (*TONApproval, error) {
  9300  	event := new(TONApproval)
  9301  	if err := _TON.contract.UnpackLog(event, "Approval", log); err != nil {
  9302  		return nil, err
  9303  	}
  9304  	return event, nil
  9305  }
  9306  
  9307  // TONMinterAddedIterator is returned from FilterMinterAdded and is used to iterate over the raw logs and unpacked data for MinterAdded events raised by the TON contract.
  9308  type TONMinterAddedIterator struct {
  9309  	Event *TONMinterAdded // Event containing the contract specifics and raw log
  9310  
  9311  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  9312  	event    string              // Event name to use for unpacking event data
  9313  
  9314  	logs chan types.Log        // Log channel receiving the found contract events
  9315  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  9316  	done bool                  // Whether the subscription completed delivering logs
  9317  	fail error                 // Occurred error to stop iteration
  9318  }
  9319  
  9320  // Next advances the iterator to the subsequent event, returning whether there
  9321  // are any more events found. In case of a retrieval or parsing error, false is
  9322  // returned and Error() can be queried for the exact failure.
  9323  func (it *TONMinterAddedIterator) Next() bool {
  9324  	// If the iterator failed, stop iterating
  9325  	if it.fail != nil {
  9326  		return false
  9327  	}
  9328  	// If the iterator completed, deliver directly whatever's available
  9329  	if it.done {
  9330  		select {
  9331  		case log := <-it.logs:
  9332  			it.Event = new(TONMinterAdded)
  9333  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  9334  				it.fail = err
  9335  				return false
  9336  			}
  9337  			it.Event.Raw = log
  9338  			return true
  9339  
  9340  		default:
  9341  			return false
  9342  		}
  9343  	}
  9344  	// Iterator still in progress, wait for either a data or an error event
  9345  	select {
  9346  	case log := <-it.logs:
  9347  		it.Event = new(TONMinterAdded)
  9348  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  9349  			it.fail = err
  9350  			return false
  9351  		}
  9352  		it.Event.Raw = log
  9353  		return true
  9354  
  9355  	case err := <-it.sub.Err():
  9356  		it.done = true
  9357  		it.fail = err
  9358  		return it.Next()
  9359  	}
  9360  }
  9361  
  9362  // Error returns any retrieval or parsing error occurred during filtering.
  9363  func (it *TONMinterAddedIterator) Error() error {
  9364  	return it.fail
  9365  }
  9366  
  9367  // Close terminates the iteration process, releasing any pending underlying
  9368  // resources.
  9369  func (it *TONMinterAddedIterator) Close() error {
  9370  	it.sub.Unsubscribe()
  9371  	return nil
  9372  }
  9373  
  9374  // TONMinterAdded represents a MinterAdded event raised by the TON contract.
  9375  type TONMinterAdded struct {
  9376  	Account common.Address
  9377  	Raw     types.Log // Blockchain specific contextual infos
  9378  }
  9379  
  9380  // FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
  9381  //
  9382  // Solidity: event MinterAdded(address indexed account)
  9383  func (_TON *TONFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*TONMinterAddedIterator, error) {
  9384  
  9385  	var accountRule []interface{}
  9386  	for _, accountItem := range account {
  9387  		accountRule = append(accountRule, accountItem)
  9388  	}
  9389  
  9390  	logs, sub, err := _TON.contract.FilterLogs(opts, "MinterAdded", accountRule)
  9391  	if err != nil {
  9392  		return nil, err
  9393  	}
  9394  	return &TONMinterAddedIterator{contract: _TON.contract, event: "MinterAdded", logs: logs, sub: sub}, nil
  9395  }
  9396  
  9397  // WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
  9398  //
  9399  // Solidity: event MinterAdded(address indexed account)
  9400  func (_TON *TONFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *TONMinterAdded, account []common.Address) (event.Subscription, error) {
  9401  
  9402  	var accountRule []interface{}
  9403  	for _, accountItem := range account {
  9404  		accountRule = append(accountRule, accountItem)
  9405  	}
  9406  
  9407  	logs, sub, err := _TON.contract.WatchLogs(opts, "MinterAdded", accountRule)
  9408  	if err != nil {
  9409  		return nil, err
  9410  	}
  9411  	return event.NewSubscription(func(quit <-chan struct{}) error {
  9412  		defer sub.Unsubscribe()
  9413  		for {
  9414  			select {
  9415  			case log := <-logs:
  9416  				// New log arrived, parse the event and forward to the user
  9417  				event := new(TONMinterAdded)
  9418  				if err := _TON.contract.UnpackLog(event, "MinterAdded", log); err != nil {
  9419  					return err
  9420  				}
  9421  				event.Raw = log
  9422  
  9423  				select {
  9424  				case sink <- event:
  9425  				case err := <-sub.Err():
  9426  					return err
  9427  				case <-quit:
  9428  					return nil
  9429  				}
  9430  			case err := <-sub.Err():
  9431  				return err
  9432  			case <-quit:
  9433  				return nil
  9434  			}
  9435  		}
  9436  	}), nil
  9437  }
  9438  
  9439  // ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
  9440  //
  9441  // Solidity: event MinterAdded(address indexed account)
  9442  func (_TON *TONFilterer) ParseMinterAdded(log types.Log) (*TONMinterAdded, error) {
  9443  	event := new(TONMinterAdded)
  9444  	if err := _TON.contract.UnpackLog(event, "MinterAdded", log); err != nil {
  9445  		return nil, err
  9446  	}
  9447  	return event, nil
  9448  }
  9449  
  9450  // TONMinterRemovedIterator is returned from FilterMinterRemoved and is used to iterate over the raw logs and unpacked data for MinterRemoved events raised by the TON contract.
  9451  type TONMinterRemovedIterator struct {
  9452  	Event *TONMinterRemoved // Event containing the contract specifics and raw log
  9453  
  9454  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  9455  	event    string              // Event name to use for unpacking event data
  9456  
  9457  	logs chan types.Log        // Log channel receiving the found contract events
  9458  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  9459  	done bool                  // Whether the subscription completed delivering logs
  9460  	fail error                 // Occurred error to stop iteration
  9461  }
  9462  
  9463  // Next advances the iterator to the subsequent event, returning whether there
  9464  // are any more events found. In case of a retrieval or parsing error, false is
  9465  // returned and Error() can be queried for the exact failure.
  9466  func (it *TONMinterRemovedIterator) Next() bool {
  9467  	// If the iterator failed, stop iterating
  9468  	if it.fail != nil {
  9469  		return false
  9470  	}
  9471  	// If the iterator completed, deliver directly whatever's available
  9472  	if it.done {
  9473  		select {
  9474  		case log := <-it.logs:
  9475  			it.Event = new(TONMinterRemoved)
  9476  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  9477  				it.fail = err
  9478  				return false
  9479  			}
  9480  			it.Event.Raw = log
  9481  			return true
  9482  
  9483  		default:
  9484  			return false
  9485  		}
  9486  	}
  9487  	// Iterator still in progress, wait for either a data or an error event
  9488  	select {
  9489  	case log := <-it.logs:
  9490  		it.Event = new(TONMinterRemoved)
  9491  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  9492  			it.fail = err
  9493  			return false
  9494  		}
  9495  		it.Event.Raw = log
  9496  		return true
  9497  
  9498  	case err := <-it.sub.Err():
  9499  		it.done = true
  9500  		it.fail = err
  9501  		return it.Next()
  9502  	}
  9503  }
  9504  
  9505  // Error returns any retrieval or parsing error occurred during filtering.
  9506  func (it *TONMinterRemovedIterator) Error() error {
  9507  	return it.fail
  9508  }
  9509  
  9510  // Close terminates the iteration process, releasing any pending underlying
  9511  // resources.
  9512  func (it *TONMinterRemovedIterator) Close() error {
  9513  	it.sub.Unsubscribe()
  9514  	return nil
  9515  }
  9516  
  9517  // TONMinterRemoved represents a MinterRemoved event raised by the TON contract.
  9518  type TONMinterRemoved struct {
  9519  	Account common.Address
  9520  	Raw     types.Log // Blockchain specific contextual infos
  9521  }
  9522  
  9523  // FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
  9524  //
  9525  // Solidity: event MinterRemoved(address indexed account)
  9526  func (_TON *TONFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*TONMinterRemovedIterator, error) {
  9527  
  9528  	var accountRule []interface{}
  9529  	for _, accountItem := range account {
  9530  		accountRule = append(accountRule, accountItem)
  9531  	}
  9532  
  9533  	logs, sub, err := _TON.contract.FilterLogs(opts, "MinterRemoved", accountRule)
  9534  	if err != nil {
  9535  		return nil, err
  9536  	}
  9537  	return &TONMinterRemovedIterator{contract: _TON.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil
  9538  }
  9539  
  9540  // WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
  9541  //
  9542  // Solidity: event MinterRemoved(address indexed account)
  9543  func (_TON *TONFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *TONMinterRemoved, account []common.Address) (event.Subscription, error) {
  9544  
  9545  	var accountRule []interface{}
  9546  	for _, accountItem := range account {
  9547  		accountRule = append(accountRule, accountItem)
  9548  	}
  9549  
  9550  	logs, sub, err := _TON.contract.WatchLogs(opts, "MinterRemoved", accountRule)
  9551  	if err != nil {
  9552  		return nil, err
  9553  	}
  9554  	return event.NewSubscription(func(quit <-chan struct{}) error {
  9555  		defer sub.Unsubscribe()
  9556  		for {
  9557  			select {
  9558  			case log := <-logs:
  9559  				// New log arrived, parse the event and forward to the user
  9560  				event := new(TONMinterRemoved)
  9561  				if err := _TON.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
  9562  					return err
  9563  				}
  9564  				event.Raw = log
  9565  
  9566  				select {
  9567  				case sink <- event:
  9568  				case err := <-sub.Err():
  9569  					return err
  9570  				case <-quit:
  9571  					return nil
  9572  				}
  9573  			case err := <-sub.Err():
  9574  				return err
  9575  			case <-quit:
  9576  				return nil
  9577  			}
  9578  		}
  9579  	}), nil
  9580  }
  9581  
  9582  // ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
  9583  //
  9584  // Solidity: event MinterRemoved(address indexed account)
  9585  func (_TON *TONFilterer) ParseMinterRemoved(log types.Log) (*TONMinterRemoved, error) {
  9586  	event := new(TONMinterRemoved)
  9587  	if err := _TON.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
  9588  		return nil, err
  9589  	}
  9590  	return event, nil
  9591  }
  9592  
  9593  // TONOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the TON contract.
  9594  type TONOwnershipTransferredIterator struct {
  9595  	Event *TONOwnershipTransferred // Event containing the contract specifics and raw log
  9596  
  9597  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  9598  	event    string              // Event name to use for unpacking event data
  9599  
  9600  	logs chan types.Log        // Log channel receiving the found contract events
  9601  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  9602  	done bool                  // Whether the subscription completed delivering logs
  9603  	fail error                 // Occurred error to stop iteration
  9604  }
  9605  
  9606  // Next advances the iterator to the subsequent event, returning whether there
  9607  // are any more events found. In case of a retrieval or parsing error, false is
  9608  // returned and Error() can be queried for the exact failure.
  9609  func (it *TONOwnershipTransferredIterator) Next() bool {
  9610  	// If the iterator failed, stop iterating
  9611  	if it.fail != nil {
  9612  		return false
  9613  	}
  9614  	// If the iterator completed, deliver directly whatever's available
  9615  	if it.done {
  9616  		select {
  9617  		case log := <-it.logs:
  9618  			it.Event = new(TONOwnershipTransferred)
  9619  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  9620  				it.fail = err
  9621  				return false
  9622  			}
  9623  			it.Event.Raw = log
  9624  			return true
  9625  
  9626  		default:
  9627  			return false
  9628  		}
  9629  	}
  9630  	// Iterator still in progress, wait for either a data or an error event
  9631  	select {
  9632  	case log := <-it.logs:
  9633  		it.Event = new(TONOwnershipTransferred)
  9634  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  9635  			it.fail = err
  9636  			return false
  9637  		}
  9638  		it.Event.Raw = log
  9639  		return true
  9640  
  9641  	case err := <-it.sub.Err():
  9642  		it.done = true
  9643  		it.fail = err
  9644  		return it.Next()
  9645  	}
  9646  }
  9647  
  9648  // Error returns any retrieval or parsing error occurred during filtering.
  9649  func (it *TONOwnershipTransferredIterator) Error() error {
  9650  	return it.fail
  9651  }
  9652  
  9653  // Close terminates the iteration process, releasing any pending underlying
  9654  // resources.
  9655  func (it *TONOwnershipTransferredIterator) Close() error {
  9656  	it.sub.Unsubscribe()
  9657  	return nil
  9658  }
  9659  
  9660  // TONOwnershipTransferred represents a OwnershipTransferred event raised by the TON contract.
  9661  type TONOwnershipTransferred struct {
  9662  	PreviousOwner common.Address
  9663  	NewOwner      common.Address
  9664  	Raw           types.Log // Blockchain specific contextual infos
  9665  }
  9666  
  9667  // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
  9668  //
  9669  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
  9670  func (_TON *TONFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*TONOwnershipTransferredIterator, error) {
  9671  
  9672  	var previousOwnerRule []interface{}
  9673  	for _, previousOwnerItem := range previousOwner {
  9674  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
  9675  	}
  9676  	var newOwnerRule []interface{}
  9677  	for _, newOwnerItem := range newOwner {
  9678  		newOwnerRule = append(newOwnerRule, newOwnerItem)
  9679  	}
  9680  
  9681  	logs, sub, err := _TON.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
  9682  	if err != nil {
  9683  		return nil, err
  9684  	}
  9685  	return &TONOwnershipTransferredIterator{contract: _TON.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
  9686  }
  9687  
  9688  // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
  9689  //
  9690  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
  9691  func (_TON *TONFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *TONOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {
  9692  
  9693  	var previousOwnerRule []interface{}
  9694  	for _, previousOwnerItem := range previousOwner {
  9695  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
  9696  	}
  9697  	var newOwnerRule []interface{}
  9698  	for _, newOwnerItem := range newOwner {
  9699  		newOwnerRule = append(newOwnerRule, newOwnerItem)
  9700  	}
  9701  
  9702  	logs, sub, err := _TON.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
  9703  	if err != nil {
  9704  		return nil, err
  9705  	}
  9706  	return event.NewSubscription(func(quit <-chan struct{}) error {
  9707  		defer sub.Unsubscribe()
  9708  		for {
  9709  			select {
  9710  			case log := <-logs:
  9711  				// New log arrived, parse the event and forward to the user
  9712  				event := new(TONOwnershipTransferred)
  9713  				if err := _TON.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
  9714  					return err
  9715  				}
  9716  				event.Raw = log
  9717  
  9718  				select {
  9719  				case sink <- event:
  9720  				case err := <-sub.Err():
  9721  					return err
  9722  				case <-quit:
  9723  					return nil
  9724  				}
  9725  			case err := <-sub.Err():
  9726  				return err
  9727  			case <-quit:
  9728  				return nil
  9729  			}
  9730  		}
  9731  	}), nil
  9732  }
  9733  
  9734  // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
  9735  //
  9736  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
  9737  func (_TON *TONFilterer) ParseOwnershipTransferred(log types.Log) (*TONOwnershipTransferred, error) {
  9738  	event := new(TONOwnershipTransferred)
  9739  	if err := _TON.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
  9740  		return nil, err
  9741  	}
  9742  	return event, nil
  9743  }
  9744  
  9745  // TONTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the TON contract.
  9746  type TONTransferIterator struct {
  9747  	Event *TONTransfer // Event containing the contract specifics and raw log
  9748  
  9749  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  9750  	event    string              // Event name to use for unpacking event data
  9751  
  9752  	logs chan types.Log        // Log channel receiving the found contract events
  9753  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  9754  	done bool                  // Whether the subscription completed delivering logs
  9755  	fail error                 // Occurred error to stop iteration
  9756  }
  9757  
  9758  // Next advances the iterator to the subsequent event, returning whether there
  9759  // are any more events found. In case of a retrieval or parsing error, false is
  9760  // returned and Error() can be queried for the exact failure.
  9761  func (it *TONTransferIterator) Next() bool {
  9762  	// If the iterator failed, stop iterating
  9763  	if it.fail != nil {
  9764  		return false
  9765  	}
  9766  	// If the iterator completed, deliver directly whatever's available
  9767  	if it.done {
  9768  		select {
  9769  		case log := <-it.logs:
  9770  			it.Event = new(TONTransfer)
  9771  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  9772  				it.fail = err
  9773  				return false
  9774  			}
  9775  			it.Event.Raw = log
  9776  			return true
  9777  
  9778  		default:
  9779  			return false
  9780  		}
  9781  	}
  9782  	// Iterator still in progress, wait for either a data or an error event
  9783  	select {
  9784  	case log := <-it.logs:
  9785  		it.Event = new(TONTransfer)
  9786  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  9787  			it.fail = err
  9788  			return false
  9789  		}
  9790  		it.Event.Raw = log
  9791  		return true
  9792  
  9793  	case err := <-it.sub.Err():
  9794  		it.done = true
  9795  		it.fail = err
  9796  		return it.Next()
  9797  	}
  9798  }
  9799  
  9800  // Error returns any retrieval or parsing error occurred during filtering.
  9801  func (it *TONTransferIterator) Error() error {
  9802  	return it.fail
  9803  }
  9804  
  9805  // Close terminates the iteration process, releasing any pending underlying
  9806  // resources.
  9807  func (it *TONTransferIterator) Close() error {
  9808  	it.sub.Unsubscribe()
  9809  	return nil
  9810  }
  9811  
  9812  // TONTransfer represents a Transfer event raised by the TON contract.
  9813  type TONTransfer struct {
  9814  	From  common.Address
  9815  	To    common.Address
  9816  	Value *big.Int
  9817  	Raw   types.Log // Blockchain specific contextual infos
  9818  }
  9819  
  9820  // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  9821  //
  9822  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  9823  func (_TON *TONFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*TONTransferIterator, error) {
  9824  
  9825  	var fromRule []interface{}
  9826  	for _, fromItem := range from {
  9827  		fromRule = append(fromRule, fromItem)
  9828  	}
  9829  	var toRule []interface{}
  9830  	for _, toItem := range to {
  9831  		toRule = append(toRule, toItem)
  9832  	}
  9833  
  9834  	logs, sub, err := _TON.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
  9835  	if err != nil {
  9836  		return nil, err
  9837  	}
  9838  	return &TONTransferIterator{contract: _TON.contract, event: "Transfer", logs: logs, sub: sub}, nil
  9839  }
  9840  
  9841  // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  9842  //
  9843  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  9844  func (_TON *TONFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *TONTransfer, from []common.Address, to []common.Address) (event.Subscription, error) {
  9845  
  9846  	var fromRule []interface{}
  9847  	for _, fromItem := range from {
  9848  		fromRule = append(fromRule, fromItem)
  9849  	}
  9850  	var toRule []interface{}
  9851  	for _, toItem := range to {
  9852  		toRule = append(toRule, toItem)
  9853  	}
  9854  
  9855  	logs, sub, err := _TON.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
  9856  	if err != nil {
  9857  		return nil, err
  9858  	}
  9859  	return event.NewSubscription(func(quit <-chan struct{}) error {
  9860  		defer sub.Unsubscribe()
  9861  		for {
  9862  			select {
  9863  			case log := <-logs:
  9864  				// New log arrived, parse the event and forward to the user
  9865  				event := new(TONTransfer)
  9866  				if err := _TON.contract.UnpackLog(event, "Transfer", log); err != nil {
  9867  					return err
  9868  				}
  9869  				event.Raw = log
  9870  
  9871  				select {
  9872  				case sink <- event:
  9873  				case err := <-sub.Err():
  9874  					return err
  9875  				case <-quit:
  9876  					return nil
  9877  				}
  9878  			case err := <-sub.Err():
  9879  				return err
  9880  			case <-quit:
  9881  				return nil
  9882  			}
  9883  		}
  9884  	}), nil
  9885  }
  9886  
  9887  // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  9888  //
  9889  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  9890  func (_TON *TONFilterer) ParseTransfer(log types.Log) (*TONTransfer, error) {
  9891  	event := new(TONTransfer)
  9892  	if err := _TON.contract.UnpackLog(event, "Transfer", log); err != nil {
  9893  		return nil, err
  9894  	}
  9895  	return event, nil
  9896  }