github.com/Onther-Tech/plasma-evm@v0.0.0-rc7.7/contracts/plasma/depositmanager/depositmanager.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 depositmanager
     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  // AddressABI is the input ABI used to generate the binding from.
    31  const AddressABI = "[]"
    32  
    33  // AddressBin is the compiled bytecode used for deploying new contracts.
    34  var AddressBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a72315820caa83848f6f3a88a061ce398577e989d5da9a19232f9e00175de410a704b86e164736f6c634300050c0032"
    35  
    36  // DeployAddress deploys a new Ethereum contract, binding an instance of Address to it.
    37  func DeployAddress(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Address, error) {
    38  	parsed, err := abi.JSON(strings.NewReader(AddressABI))
    39  	if err != nil {
    40  		return common.Address{}, nil, nil, err
    41  	}
    42  
    43  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(AddressBin), backend)
    44  	if err != nil {
    45  		return common.Address{}, nil, nil, err
    46  	}
    47  	return address, tx, &Address{AddressCaller: AddressCaller{contract: contract}, AddressTransactor: AddressTransactor{contract: contract}, AddressFilterer: AddressFilterer{contract: contract}}, nil
    48  }
    49  
    50  // Address is an auto generated Go binding around an Ethereum contract.
    51  type Address struct {
    52  	AddressCaller     // Read-only binding to the contract
    53  	AddressTransactor // Write-only binding to the contract
    54  	AddressFilterer   // Log filterer for contract events
    55  }
    56  
    57  // AddressCaller is an auto generated read-only Go binding around an Ethereum contract.
    58  type AddressCaller struct {
    59  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
    60  }
    61  
    62  // AddressTransactor is an auto generated write-only Go binding around an Ethereum contract.
    63  type AddressTransactor struct {
    64  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
    65  }
    66  
    67  // AddressFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
    68  type AddressFilterer struct {
    69  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
    70  }
    71  
    72  // AddressSession is an auto generated Go binding around an Ethereum contract,
    73  // with pre-set call and transact options.
    74  type AddressSession struct {
    75  	Contract     *Address          // Generic contract binding to set the session for
    76  	CallOpts     bind.CallOpts     // Call options to use throughout this session
    77  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
    78  }
    79  
    80  // AddressCallerSession is an auto generated read-only Go binding around an Ethereum contract,
    81  // with pre-set call options.
    82  type AddressCallerSession struct {
    83  	Contract *AddressCaller // Generic contract caller binding to set the session for
    84  	CallOpts bind.CallOpts  // Call options to use throughout this session
    85  }
    86  
    87  // AddressTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
    88  // with pre-set transact options.
    89  type AddressTransactorSession struct {
    90  	Contract     *AddressTransactor // Generic contract transactor binding to set the session for
    91  	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
    92  }
    93  
    94  // AddressRaw is an auto generated low-level Go binding around an Ethereum contract.
    95  type AddressRaw struct {
    96  	Contract *Address // Generic contract binding to access the raw methods on
    97  }
    98  
    99  // AddressCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
   100  type AddressCallerRaw struct {
   101  	Contract *AddressCaller // Generic read-only contract binding to access the raw methods on
   102  }
   103  
   104  // AddressTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
   105  type AddressTransactorRaw struct {
   106  	Contract *AddressTransactor // Generic write-only contract binding to access the raw methods on
   107  }
   108  
   109  // NewAddress creates a new instance of Address, bound to a specific deployed contract.
   110  func NewAddress(address common.Address, backend bind.ContractBackend) (*Address, error) {
   111  	contract, err := bindAddress(address, backend, backend, backend)
   112  	if err != nil {
   113  		return nil, err
   114  	}
   115  	return &Address{AddressCaller: AddressCaller{contract: contract}, AddressTransactor: AddressTransactor{contract: contract}, AddressFilterer: AddressFilterer{contract: contract}}, nil
   116  }
   117  
   118  // NewAddressCaller creates a new read-only instance of Address, bound to a specific deployed contract.
   119  func NewAddressCaller(address common.Address, caller bind.ContractCaller) (*AddressCaller, error) {
   120  	contract, err := bindAddress(address, caller, nil, nil)
   121  	if err != nil {
   122  		return nil, err
   123  	}
   124  	return &AddressCaller{contract: contract}, nil
   125  }
   126  
   127  // NewAddressTransactor creates a new write-only instance of Address, bound to a specific deployed contract.
   128  func NewAddressTransactor(address common.Address, transactor bind.ContractTransactor) (*AddressTransactor, error) {
   129  	contract, err := bindAddress(address, nil, transactor, nil)
   130  	if err != nil {
   131  		return nil, err
   132  	}
   133  	return &AddressTransactor{contract: contract}, nil
   134  }
   135  
   136  // NewAddressFilterer creates a new log filterer instance of Address, bound to a specific deployed contract.
   137  func NewAddressFilterer(address common.Address, filterer bind.ContractFilterer) (*AddressFilterer, error) {
   138  	contract, err := bindAddress(address, nil, nil, filterer)
   139  	if err != nil {
   140  		return nil, err
   141  	}
   142  	return &AddressFilterer{contract: contract}, nil
   143  }
   144  
   145  // bindAddress binds a generic wrapper to an already deployed contract.
   146  func bindAddress(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
   147  	parsed, err := abi.JSON(strings.NewReader(AddressABI))
   148  	if err != nil {
   149  		return nil, err
   150  	}
   151  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
   152  }
   153  
   154  // Call invokes the (constant) contract method with params as input values and
   155  // sets the output to result. The result type might be a single field for simple
   156  // returns, a slice of interfaces for anonymous returns and a struct for named
   157  // returns.
   158  func (_Address *AddressRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
   159  	return _Address.Contract.AddressCaller.contract.Call(opts, result, method, params...)
   160  }
   161  
   162  // Transfer initiates a plain transaction to move funds to the contract, calling
   163  // its default method if one is available.
   164  func (_Address *AddressRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   165  	return _Address.Contract.AddressTransactor.contract.Transfer(opts)
   166  }
   167  
   168  // Transact invokes the (paid) contract method with params as input values.
   169  func (_Address *AddressRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   170  	return _Address.Contract.AddressTransactor.contract.Transact(opts, method, params...)
   171  }
   172  
   173  // Call invokes the (constant) contract method with params as input values and
   174  // sets the output to result. The result type might be a single field for simple
   175  // returns, a slice of interfaces for anonymous returns and a struct for named
   176  // returns.
   177  func (_Address *AddressCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
   178  	return _Address.Contract.contract.Call(opts, result, method, params...)
   179  }
   180  
   181  // Transfer initiates a plain transaction to move funds to the contract, calling
   182  // its default method if one is available.
   183  func (_Address *AddressTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   184  	return _Address.Contract.contract.Transfer(opts)
   185  }
   186  
   187  // Transact invokes the (paid) contract method with params as input values.
   188  func (_Address *AddressTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   189  	return _Address.Contract.contract.Transact(opts, method, params...)
   190  }
   191  
   192  // AuthControllerABI is the input ABI used to generate the binding from.
   193  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\"}]"
   194  
   195  // AuthControllerFuncSigs maps the 4-byte function signature to its string representation.
   196  var AuthControllerFuncSigs = map[string]string{
   197  	"8f32d59b": "isOwner()",
   198  	"8da5cb5b": "owner()",
   199  	"5f112c68": "renounceMinter(address)",
   200  	"715018a6": "renounceOwnership()",
   201  	"38bf3cfa": "renounceOwnership(address)",
   202  	"41eb24bb": "renouncePauser(address)",
   203  	"f2fde38b": "transferOwnership(address)",
   204  	"6d435421": "transferOwnership(address,address)",
   205  }
   206  
   207  // AuthControllerBin is the compiled bytecode used for deploying new contracts.
   208  var AuthControllerBin = "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"
   209  
   210  // DeployAuthController deploys a new Ethereum contract, binding an instance of AuthController to it.
   211  func DeployAuthController(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *AuthController, error) {
   212  	parsed, err := abi.JSON(strings.NewReader(AuthControllerABI))
   213  	if err != nil {
   214  		return common.Address{}, nil, nil, err
   215  	}
   216  
   217  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(AuthControllerBin), backend)
   218  	if err != nil {
   219  		return common.Address{}, nil, nil, err
   220  	}
   221  	return address, tx, &AuthController{AuthControllerCaller: AuthControllerCaller{contract: contract}, AuthControllerTransactor: AuthControllerTransactor{contract: contract}, AuthControllerFilterer: AuthControllerFilterer{contract: contract}}, nil
   222  }
   223  
   224  // AuthController is an auto generated Go binding around an Ethereum contract.
   225  type AuthController struct {
   226  	AuthControllerCaller     // Read-only binding to the contract
   227  	AuthControllerTransactor // Write-only binding to the contract
   228  	AuthControllerFilterer   // Log filterer for contract events
   229  }
   230  
   231  // AuthControllerCaller is an auto generated read-only Go binding around an Ethereum contract.
   232  type AuthControllerCaller struct {
   233  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   234  }
   235  
   236  // AuthControllerTransactor is an auto generated write-only Go binding around an Ethereum contract.
   237  type AuthControllerTransactor struct {
   238  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   239  }
   240  
   241  // AuthControllerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
   242  type AuthControllerFilterer struct {
   243  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   244  }
   245  
   246  // AuthControllerSession is an auto generated Go binding around an Ethereum contract,
   247  // with pre-set call and transact options.
   248  type AuthControllerSession struct {
   249  	Contract     *AuthController   // Generic contract binding to set the session for
   250  	CallOpts     bind.CallOpts     // Call options to use throughout this session
   251  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
   252  }
   253  
   254  // AuthControllerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
   255  // with pre-set call options.
   256  type AuthControllerCallerSession struct {
   257  	Contract *AuthControllerCaller // Generic contract caller binding to set the session for
   258  	CallOpts bind.CallOpts         // Call options to use throughout this session
   259  }
   260  
   261  // AuthControllerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
   262  // with pre-set transact options.
   263  type AuthControllerTransactorSession struct {
   264  	Contract     *AuthControllerTransactor // Generic contract transactor binding to set the session for
   265  	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
   266  }
   267  
   268  // AuthControllerRaw is an auto generated low-level Go binding around an Ethereum contract.
   269  type AuthControllerRaw struct {
   270  	Contract *AuthController // Generic contract binding to access the raw methods on
   271  }
   272  
   273  // AuthControllerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
   274  type AuthControllerCallerRaw struct {
   275  	Contract *AuthControllerCaller // Generic read-only contract binding to access the raw methods on
   276  }
   277  
   278  // AuthControllerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
   279  type AuthControllerTransactorRaw struct {
   280  	Contract *AuthControllerTransactor // Generic write-only contract binding to access the raw methods on
   281  }
   282  
   283  // NewAuthController creates a new instance of AuthController, bound to a specific deployed contract.
   284  func NewAuthController(address common.Address, backend bind.ContractBackend) (*AuthController, error) {
   285  	contract, err := bindAuthController(address, backend, backend, backend)
   286  	if err != nil {
   287  		return nil, err
   288  	}
   289  	return &AuthController{AuthControllerCaller: AuthControllerCaller{contract: contract}, AuthControllerTransactor: AuthControllerTransactor{contract: contract}, AuthControllerFilterer: AuthControllerFilterer{contract: contract}}, nil
   290  }
   291  
   292  // NewAuthControllerCaller creates a new read-only instance of AuthController, bound to a specific deployed contract.
   293  func NewAuthControllerCaller(address common.Address, caller bind.ContractCaller) (*AuthControllerCaller, error) {
   294  	contract, err := bindAuthController(address, caller, nil, nil)
   295  	if err != nil {
   296  		return nil, err
   297  	}
   298  	return &AuthControllerCaller{contract: contract}, nil
   299  }
   300  
   301  // NewAuthControllerTransactor creates a new write-only instance of AuthController, bound to a specific deployed contract.
   302  func NewAuthControllerTransactor(address common.Address, transactor bind.ContractTransactor) (*AuthControllerTransactor, error) {
   303  	contract, err := bindAuthController(address, nil, transactor, nil)
   304  	if err != nil {
   305  		return nil, err
   306  	}
   307  	return &AuthControllerTransactor{contract: contract}, nil
   308  }
   309  
   310  // NewAuthControllerFilterer creates a new log filterer instance of AuthController, bound to a specific deployed contract.
   311  func NewAuthControllerFilterer(address common.Address, filterer bind.ContractFilterer) (*AuthControllerFilterer, error) {
   312  	contract, err := bindAuthController(address, nil, nil, filterer)
   313  	if err != nil {
   314  		return nil, err
   315  	}
   316  	return &AuthControllerFilterer{contract: contract}, nil
   317  }
   318  
   319  // bindAuthController binds a generic wrapper to an already deployed contract.
   320  func bindAuthController(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
   321  	parsed, err := abi.JSON(strings.NewReader(AuthControllerABI))
   322  	if err != nil {
   323  		return nil, err
   324  	}
   325  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
   326  }
   327  
   328  // Call invokes the (constant) contract method with params as input values and
   329  // sets the output to result. The result type might be a single field for simple
   330  // returns, a slice of interfaces for anonymous returns and a struct for named
   331  // returns.
   332  func (_AuthController *AuthControllerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
   333  	return _AuthController.Contract.AuthControllerCaller.contract.Call(opts, result, method, params...)
   334  }
   335  
   336  // Transfer initiates a plain transaction to move funds to the contract, calling
   337  // its default method if one is available.
   338  func (_AuthController *AuthControllerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   339  	return _AuthController.Contract.AuthControllerTransactor.contract.Transfer(opts)
   340  }
   341  
   342  // Transact invokes the (paid) contract method with params as input values.
   343  func (_AuthController *AuthControllerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   344  	return _AuthController.Contract.AuthControllerTransactor.contract.Transact(opts, method, params...)
   345  }
   346  
   347  // Call invokes the (constant) contract method with params as input values and
   348  // sets the output to result. The result type might be a single field for simple
   349  // returns, a slice of interfaces for anonymous returns and a struct for named
   350  // returns.
   351  func (_AuthController *AuthControllerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
   352  	return _AuthController.Contract.contract.Call(opts, result, method, params...)
   353  }
   354  
   355  // Transfer initiates a plain transaction to move funds to the contract, calling
   356  // its default method if one is available.
   357  func (_AuthController *AuthControllerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   358  	return _AuthController.Contract.contract.Transfer(opts)
   359  }
   360  
   361  // Transact invokes the (paid) contract method with params as input values.
   362  func (_AuthController *AuthControllerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   363  	return _AuthController.Contract.contract.Transact(opts, method, params...)
   364  }
   365  
   366  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
   367  //
   368  // Solidity: function isOwner() constant returns(bool)
   369  func (_AuthController *AuthControllerCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
   370  	var (
   371  		ret0 = new(bool)
   372  	)
   373  	out := ret0
   374  	err := _AuthController.contract.Call(opts, out, "isOwner")
   375  	return *ret0, err
   376  }
   377  
   378  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
   379  //
   380  // Solidity: function isOwner() constant returns(bool)
   381  func (_AuthController *AuthControllerSession) IsOwner() (bool, error) {
   382  	return _AuthController.Contract.IsOwner(&_AuthController.CallOpts)
   383  }
   384  
   385  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
   386  //
   387  // Solidity: function isOwner() constant returns(bool)
   388  func (_AuthController *AuthControllerCallerSession) IsOwner() (bool, error) {
   389  	return _AuthController.Contract.IsOwner(&_AuthController.CallOpts)
   390  }
   391  
   392  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
   393  //
   394  // Solidity: function owner() constant returns(address)
   395  func (_AuthController *AuthControllerCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
   396  	var (
   397  		ret0 = new(common.Address)
   398  	)
   399  	out := ret0
   400  	err := _AuthController.contract.Call(opts, out, "owner")
   401  	return *ret0, err
   402  }
   403  
   404  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
   405  //
   406  // Solidity: function owner() constant returns(address)
   407  func (_AuthController *AuthControllerSession) Owner() (common.Address, error) {
   408  	return _AuthController.Contract.Owner(&_AuthController.CallOpts)
   409  }
   410  
   411  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
   412  //
   413  // Solidity: function owner() constant returns(address)
   414  func (_AuthController *AuthControllerCallerSession) Owner() (common.Address, error) {
   415  	return _AuthController.Contract.Owner(&_AuthController.CallOpts)
   416  }
   417  
   418  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
   419  //
   420  // Solidity: function renounceMinter(address target) returns()
   421  func (_AuthController *AuthControllerTransactor) RenounceMinter(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
   422  	return _AuthController.contract.Transact(opts, "renounceMinter", target)
   423  }
   424  
   425  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
   426  //
   427  // Solidity: function renounceMinter(address target) returns()
   428  func (_AuthController *AuthControllerSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
   429  	return _AuthController.Contract.RenounceMinter(&_AuthController.TransactOpts, target)
   430  }
   431  
   432  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
   433  //
   434  // Solidity: function renounceMinter(address target) returns()
   435  func (_AuthController *AuthControllerTransactorSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
   436  	return _AuthController.Contract.RenounceMinter(&_AuthController.TransactOpts, target)
   437  }
   438  
   439  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
   440  //
   441  // Solidity: function renounceOwnership(address target) returns()
   442  func (_AuthController *AuthControllerTransactor) RenounceOwnership(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
   443  	return _AuthController.contract.Transact(opts, "renounceOwnership", target)
   444  }
   445  
   446  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
   447  //
   448  // Solidity: function renounceOwnership(address target) returns()
   449  func (_AuthController *AuthControllerSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
   450  	return _AuthController.Contract.RenounceOwnership(&_AuthController.TransactOpts, target)
   451  }
   452  
   453  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
   454  //
   455  // Solidity: function renounceOwnership(address target) returns()
   456  func (_AuthController *AuthControllerTransactorSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
   457  	return _AuthController.Contract.RenounceOwnership(&_AuthController.TransactOpts, target)
   458  }
   459  
   460  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
   461  //
   462  // Solidity: function renounceOwnership() returns()
   463  func (_AuthController *AuthControllerTransactor) RenounceOwnership0(opts *bind.TransactOpts) (*types.Transaction, error) {
   464  	return _AuthController.contract.Transact(opts, "renounceOwnership0")
   465  }
   466  
   467  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
   468  //
   469  // Solidity: function renounceOwnership() returns()
   470  func (_AuthController *AuthControllerSession) RenounceOwnership0() (*types.Transaction, error) {
   471  	return _AuthController.Contract.RenounceOwnership0(&_AuthController.TransactOpts)
   472  }
   473  
   474  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
   475  //
   476  // Solidity: function renounceOwnership() returns()
   477  func (_AuthController *AuthControllerTransactorSession) RenounceOwnership0() (*types.Transaction, error) {
   478  	return _AuthController.Contract.RenounceOwnership0(&_AuthController.TransactOpts)
   479  }
   480  
   481  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
   482  //
   483  // Solidity: function renouncePauser(address target) returns()
   484  func (_AuthController *AuthControllerTransactor) RenouncePauser(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
   485  	return _AuthController.contract.Transact(opts, "renouncePauser", target)
   486  }
   487  
   488  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
   489  //
   490  // Solidity: function renouncePauser(address target) returns()
   491  func (_AuthController *AuthControllerSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
   492  	return _AuthController.Contract.RenouncePauser(&_AuthController.TransactOpts, target)
   493  }
   494  
   495  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
   496  //
   497  // Solidity: function renouncePauser(address target) returns()
   498  func (_AuthController *AuthControllerTransactorSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
   499  	return _AuthController.Contract.RenouncePauser(&_AuthController.TransactOpts, target)
   500  }
   501  
   502  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
   503  //
   504  // Solidity: function transferOwnership(address target, address newOwner) returns()
   505  func (_AuthController *AuthControllerTransactor) TransferOwnership(opts *bind.TransactOpts, target common.Address, newOwner common.Address) (*types.Transaction, error) {
   506  	return _AuthController.contract.Transact(opts, "transferOwnership", target, newOwner)
   507  }
   508  
   509  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
   510  //
   511  // Solidity: function transferOwnership(address target, address newOwner) returns()
   512  func (_AuthController *AuthControllerSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
   513  	return _AuthController.Contract.TransferOwnership(&_AuthController.TransactOpts, target, newOwner)
   514  }
   515  
   516  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
   517  //
   518  // Solidity: function transferOwnership(address target, address newOwner) returns()
   519  func (_AuthController *AuthControllerTransactorSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
   520  	return _AuthController.Contract.TransferOwnership(&_AuthController.TransactOpts, target, newOwner)
   521  }
   522  
   523  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
   524  //
   525  // Solidity: function transferOwnership(address newOwner) returns()
   526  func (_AuthController *AuthControllerTransactor) TransferOwnership0(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
   527  	return _AuthController.contract.Transact(opts, "transferOwnership0", newOwner)
   528  }
   529  
   530  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
   531  //
   532  // Solidity: function transferOwnership(address newOwner) returns()
   533  func (_AuthController *AuthControllerSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
   534  	return _AuthController.Contract.TransferOwnership0(&_AuthController.TransactOpts, newOwner)
   535  }
   536  
   537  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
   538  //
   539  // Solidity: function transferOwnership(address newOwner) returns()
   540  func (_AuthController *AuthControllerTransactorSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
   541  	return _AuthController.Contract.TransferOwnership0(&_AuthController.TransactOpts, newOwner)
   542  }
   543  
   544  // 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.
   545  type AuthControllerOwnershipTransferredIterator struct {
   546  	Event *AuthControllerOwnershipTransferred // Event containing the contract specifics and raw log
   547  
   548  	contract *bind.BoundContract // Generic contract to use for unpacking event data
   549  	event    string              // Event name to use for unpacking event data
   550  
   551  	logs chan types.Log        // Log channel receiving the found contract events
   552  	sub  ethereum.Subscription // Subscription for errors, completion and termination
   553  	done bool                  // Whether the subscription completed delivering logs
   554  	fail error                 // Occurred error to stop iteration
   555  }
   556  
   557  // Next advances the iterator to the subsequent event, returning whether there
   558  // are any more events found. In case of a retrieval or parsing error, false is
   559  // returned and Error() can be queried for the exact failure.
   560  func (it *AuthControllerOwnershipTransferredIterator) Next() bool {
   561  	// If the iterator failed, stop iterating
   562  	if it.fail != nil {
   563  		return false
   564  	}
   565  	// If the iterator completed, deliver directly whatever's available
   566  	if it.done {
   567  		select {
   568  		case log := <-it.logs:
   569  			it.Event = new(AuthControllerOwnershipTransferred)
   570  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
   571  				it.fail = err
   572  				return false
   573  			}
   574  			it.Event.Raw = log
   575  			return true
   576  
   577  		default:
   578  			return false
   579  		}
   580  	}
   581  	// Iterator still in progress, wait for either a data or an error event
   582  	select {
   583  	case log := <-it.logs:
   584  		it.Event = new(AuthControllerOwnershipTransferred)
   585  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
   586  			it.fail = err
   587  			return false
   588  		}
   589  		it.Event.Raw = log
   590  		return true
   591  
   592  	case err := <-it.sub.Err():
   593  		it.done = true
   594  		it.fail = err
   595  		return it.Next()
   596  	}
   597  }
   598  
   599  // Error returns any retrieval or parsing error occurred during filtering.
   600  func (it *AuthControllerOwnershipTransferredIterator) Error() error {
   601  	return it.fail
   602  }
   603  
   604  // Close terminates the iteration process, releasing any pending underlying
   605  // resources.
   606  func (it *AuthControllerOwnershipTransferredIterator) Close() error {
   607  	it.sub.Unsubscribe()
   608  	return nil
   609  }
   610  
   611  // AuthControllerOwnershipTransferred represents a OwnershipTransferred event raised by the AuthController contract.
   612  type AuthControllerOwnershipTransferred struct {
   613  	PreviousOwner common.Address
   614  	NewOwner      common.Address
   615  	Raw           types.Log // Blockchain specific contextual infos
   616  }
   617  
   618  // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
   619  //
   620  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
   621  func (_AuthController *AuthControllerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*AuthControllerOwnershipTransferredIterator, error) {
   622  
   623  	var previousOwnerRule []interface{}
   624  	for _, previousOwnerItem := range previousOwner {
   625  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
   626  	}
   627  	var newOwnerRule []interface{}
   628  	for _, newOwnerItem := range newOwner {
   629  		newOwnerRule = append(newOwnerRule, newOwnerItem)
   630  	}
   631  
   632  	logs, sub, err := _AuthController.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
   633  	if err != nil {
   634  		return nil, err
   635  	}
   636  	return &AuthControllerOwnershipTransferredIterator{contract: _AuthController.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
   637  }
   638  
   639  // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
   640  //
   641  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
   642  func (_AuthController *AuthControllerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *AuthControllerOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {
   643  
   644  	var previousOwnerRule []interface{}
   645  	for _, previousOwnerItem := range previousOwner {
   646  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
   647  	}
   648  	var newOwnerRule []interface{}
   649  	for _, newOwnerItem := range newOwner {
   650  		newOwnerRule = append(newOwnerRule, newOwnerItem)
   651  	}
   652  
   653  	logs, sub, err := _AuthController.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
   654  	if err != nil {
   655  		return nil, err
   656  	}
   657  	return event.NewSubscription(func(quit <-chan struct{}) error {
   658  		defer sub.Unsubscribe()
   659  		for {
   660  			select {
   661  			case log := <-logs:
   662  				// New log arrived, parse the event and forward to the user
   663  				event := new(AuthControllerOwnershipTransferred)
   664  				if err := _AuthController.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
   665  					return err
   666  				}
   667  				event.Raw = log
   668  
   669  				select {
   670  				case sink <- event:
   671  				case err := <-sub.Err():
   672  					return err
   673  				case <-quit:
   674  					return nil
   675  				}
   676  			case err := <-sub.Err():
   677  				return err
   678  			case <-quit:
   679  				return nil
   680  			}
   681  		}
   682  	}), nil
   683  }
   684  
   685  // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
   686  //
   687  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
   688  func (_AuthController *AuthControllerFilterer) ParseOwnershipTransferred(log types.Log) (*AuthControllerOwnershipTransferred, error) {
   689  	event := new(AuthControllerOwnershipTransferred)
   690  	if err := _AuthController.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
   691  		return nil, err
   692  	}
   693  	return event, nil
   694  }
   695  
   696  // ContextABI is the input ABI used to generate the binding from.
   697  const ContextABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]"
   698  
   699  // Context is an auto generated Go binding around an Ethereum contract.
   700  type Context struct {
   701  	ContextCaller     // Read-only binding to the contract
   702  	ContextTransactor // Write-only binding to the contract
   703  	ContextFilterer   // Log filterer for contract events
   704  }
   705  
   706  // ContextCaller is an auto generated read-only Go binding around an Ethereum contract.
   707  type ContextCaller struct {
   708  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   709  }
   710  
   711  // ContextTransactor is an auto generated write-only Go binding around an Ethereum contract.
   712  type ContextTransactor struct {
   713  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   714  }
   715  
   716  // ContextFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
   717  type ContextFilterer struct {
   718  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   719  }
   720  
   721  // ContextSession is an auto generated Go binding around an Ethereum contract,
   722  // with pre-set call and transact options.
   723  type ContextSession struct {
   724  	Contract     *Context          // 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  // ContextCallerSession is an auto generated read-only Go binding around an Ethereum contract,
   730  // with pre-set call options.
   731  type ContextCallerSession struct {
   732  	Contract *ContextCaller // Generic contract caller binding to set the session for
   733  	CallOpts bind.CallOpts  // Call options to use throughout this session
   734  }
   735  
   736  // ContextTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
   737  // with pre-set transact options.
   738  type ContextTransactorSession struct {
   739  	Contract     *ContextTransactor // Generic contract transactor binding to set the session for
   740  	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
   741  }
   742  
   743  // ContextRaw is an auto generated low-level Go binding around an Ethereum contract.
   744  type ContextRaw struct {
   745  	Contract *Context // Generic contract binding to access the raw methods on
   746  }
   747  
   748  // ContextCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
   749  type ContextCallerRaw struct {
   750  	Contract *ContextCaller // Generic read-only contract binding to access the raw methods on
   751  }
   752  
   753  // ContextTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
   754  type ContextTransactorRaw struct {
   755  	Contract *ContextTransactor // Generic write-only contract binding to access the raw methods on
   756  }
   757  
   758  // NewContext creates a new instance of Context, bound to a specific deployed contract.
   759  func NewContext(address common.Address, backend bind.ContractBackend) (*Context, error) {
   760  	contract, err := bindContext(address, backend, backend, backend)
   761  	if err != nil {
   762  		return nil, err
   763  	}
   764  	return &Context{ContextCaller: ContextCaller{contract: contract}, ContextTransactor: ContextTransactor{contract: contract}, ContextFilterer: ContextFilterer{contract: contract}}, nil
   765  }
   766  
   767  // NewContextCaller creates a new read-only instance of Context, bound to a specific deployed contract.
   768  func NewContextCaller(address common.Address, caller bind.ContractCaller) (*ContextCaller, error) {
   769  	contract, err := bindContext(address, caller, nil, nil)
   770  	if err != nil {
   771  		return nil, err
   772  	}
   773  	return &ContextCaller{contract: contract}, nil
   774  }
   775  
   776  // NewContextTransactor creates a new write-only instance of Context, bound to a specific deployed contract.
   777  func NewContextTransactor(address common.Address, transactor bind.ContractTransactor) (*ContextTransactor, error) {
   778  	contract, err := bindContext(address, nil, transactor, nil)
   779  	if err != nil {
   780  		return nil, err
   781  	}
   782  	return &ContextTransactor{contract: contract}, nil
   783  }
   784  
   785  // NewContextFilterer creates a new log filterer instance of Context, bound to a specific deployed contract.
   786  func NewContextFilterer(address common.Address, filterer bind.ContractFilterer) (*ContextFilterer, error) {
   787  	contract, err := bindContext(address, nil, nil, filterer)
   788  	if err != nil {
   789  		return nil, err
   790  	}
   791  	return &ContextFilterer{contract: contract}, nil
   792  }
   793  
   794  // bindContext binds a generic wrapper to an already deployed contract.
   795  func bindContext(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
   796  	parsed, err := abi.JSON(strings.NewReader(ContextABI))
   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 (_Context *ContextRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
   808  	return _Context.Contract.ContextCaller.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 (_Context *ContextRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   814  	return _Context.Contract.ContextTransactor.contract.Transfer(opts)
   815  }
   816  
   817  // Transact invokes the (paid) contract method with params as input values.
   818  func (_Context *ContextRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   819  	return _Context.Contract.ContextTransactor.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 (_Context *ContextCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
   827  	return _Context.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 (_Context *ContextTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   833  	return _Context.Contract.contract.Transfer(opts)
   834  }
   835  
   836  // Transact invokes the (paid) contract method with params as input values.
   837  func (_Context *ContextTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   838  	return _Context.Contract.contract.Transact(opts, method, params...)
   839  }
   840  
   841  // DSMathABI is the input ABI used to generate the binding from.
   842  const DSMathABI = "[]"
   843  
   844  // DSMathBin is the compiled bytecode used for deploying new contracts.
   845  var DSMathBin = "0x6080604052348015600f57600080fd5b50603e80601d6000396000f3fe6080604052600080fdfea265627a7a723158201d3383a4efea7d4c911511edcc2240f991199f32cf3b3c855dd9ffb45f3f45a164736f6c634300050c0032"
   846  
   847  // DeployDSMath deploys a new Ethereum contract, binding an instance of DSMath to it.
   848  func DeployDSMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *DSMath, error) {
   849  	parsed, err := abi.JSON(strings.NewReader(DSMathABI))
   850  	if err != nil {
   851  		return common.Address{}, nil, nil, err
   852  	}
   853  
   854  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(DSMathBin), backend)
   855  	if err != nil {
   856  		return common.Address{}, nil, nil, err
   857  	}
   858  	return address, tx, &DSMath{DSMathCaller: DSMathCaller{contract: contract}, DSMathTransactor: DSMathTransactor{contract: contract}, DSMathFilterer: DSMathFilterer{contract: contract}}, nil
   859  }
   860  
   861  // DSMath is an auto generated Go binding around an Ethereum contract.
   862  type DSMath struct {
   863  	DSMathCaller     // Read-only binding to the contract
   864  	DSMathTransactor // Write-only binding to the contract
   865  	DSMathFilterer   // Log filterer for contract events
   866  }
   867  
   868  // DSMathCaller is an auto generated read-only Go binding around an Ethereum contract.
   869  type DSMathCaller struct {
   870  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   871  }
   872  
   873  // DSMathTransactor is an auto generated write-only Go binding around an Ethereum contract.
   874  type DSMathTransactor struct {
   875  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   876  }
   877  
   878  // DSMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
   879  type DSMathFilterer struct {
   880  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   881  }
   882  
   883  // DSMathSession is an auto generated Go binding around an Ethereum contract,
   884  // with pre-set call and transact options.
   885  type DSMathSession struct {
   886  	Contract     *DSMath           // Generic contract binding to set the session for
   887  	CallOpts     bind.CallOpts     // Call options to use throughout this session
   888  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
   889  }
   890  
   891  // DSMathCallerSession is an auto generated read-only Go binding around an Ethereum contract,
   892  // with pre-set call options.
   893  type DSMathCallerSession struct {
   894  	Contract *DSMathCaller // Generic contract caller binding to set the session for
   895  	CallOpts bind.CallOpts // Call options to use throughout this session
   896  }
   897  
   898  // DSMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
   899  // with pre-set transact options.
   900  type DSMathTransactorSession struct {
   901  	Contract     *DSMathTransactor // Generic contract transactor binding to set the session for
   902  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
   903  }
   904  
   905  // DSMathRaw is an auto generated low-level Go binding around an Ethereum contract.
   906  type DSMathRaw struct {
   907  	Contract *DSMath // Generic contract binding to access the raw methods on
   908  }
   909  
   910  // DSMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
   911  type DSMathCallerRaw struct {
   912  	Contract *DSMathCaller // Generic read-only contract binding to access the raw methods on
   913  }
   914  
   915  // DSMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
   916  type DSMathTransactorRaw struct {
   917  	Contract *DSMathTransactor // Generic write-only contract binding to access the raw methods on
   918  }
   919  
   920  // NewDSMath creates a new instance of DSMath, bound to a specific deployed contract.
   921  func NewDSMath(address common.Address, backend bind.ContractBackend) (*DSMath, error) {
   922  	contract, err := bindDSMath(address, backend, backend, backend)
   923  	if err != nil {
   924  		return nil, err
   925  	}
   926  	return &DSMath{DSMathCaller: DSMathCaller{contract: contract}, DSMathTransactor: DSMathTransactor{contract: contract}, DSMathFilterer: DSMathFilterer{contract: contract}}, nil
   927  }
   928  
   929  // NewDSMathCaller creates a new read-only instance of DSMath, bound to a specific deployed contract.
   930  func NewDSMathCaller(address common.Address, caller bind.ContractCaller) (*DSMathCaller, error) {
   931  	contract, err := bindDSMath(address, caller, nil, nil)
   932  	if err != nil {
   933  		return nil, err
   934  	}
   935  	return &DSMathCaller{contract: contract}, nil
   936  }
   937  
   938  // NewDSMathTransactor creates a new write-only instance of DSMath, bound to a specific deployed contract.
   939  func NewDSMathTransactor(address common.Address, transactor bind.ContractTransactor) (*DSMathTransactor, error) {
   940  	contract, err := bindDSMath(address, nil, transactor, nil)
   941  	if err != nil {
   942  		return nil, err
   943  	}
   944  	return &DSMathTransactor{contract: contract}, nil
   945  }
   946  
   947  // NewDSMathFilterer creates a new log filterer instance of DSMath, bound to a specific deployed contract.
   948  func NewDSMathFilterer(address common.Address, filterer bind.ContractFilterer) (*DSMathFilterer, error) {
   949  	contract, err := bindDSMath(address, nil, nil, filterer)
   950  	if err != nil {
   951  		return nil, err
   952  	}
   953  	return &DSMathFilterer{contract: contract}, nil
   954  }
   955  
   956  // bindDSMath binds a generic wrapper to an already deployed contract.
   957  func bindDSMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
   958  	parsed, err := abi.JSON(strings.NewReader(DSMathABI))
   959  	if err != nil {
   960  		return nil, err
   961  	}
   962  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
   963  }
   964  
   965  // Call invokes the (constant) contract method with params as input values and
   966  // sets the output to result. The result type might be a single field for simple
   967  // returns, a slice of interfaces for anonymous returns and a struct for named
   968  // returns.
   969  func (_DSMath *DSMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
   970  	return _DSMath.Contract.DSMathCaller.contract.Call(opts, result, method, params...)
   971  }
   972  
   973  // Transfer initiates a plain transaction to move funds to the contract, calling
   974  // its default method if one is available.
   975  func (_DSMath *DSMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   976  	return _DSMath.Contract.DSMathTransactor.contract.Transfer(opts)
   977  }
   978  
   979  // Transact invokes the (paid) contract method with params as input values.
   980  func (_DSMath *DSMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   981  	return _DSMath.Contract.DSMathTransactor.contract.Transact(opts, method, params...)
   982  }
   983  
   984  // Call invokes the (constant) contract method with params as input values and
   985  // sets the output to result. The result type might be a single field for simple
   986  // returns, a slice of interfaces for anonymous returns and a struct for named
   987  // returns.
   988  func (_DSMath *DSMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
   989  	return _DSMath.Contract.contract.Call(opts, result, method, params...)
   990  }
   991  
   992  // Transfer initiates a plain transaction to move funds to the contract, calling
   993  // its default method if one is available.
   994  func (_DSMath *DSMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   995  	return _DSMath.Contract.contract.Transfer(opts)
   996  }
   997  
   998  // Transact invokes the (paid) contract method with params as input values.
   999  func (_DSMath *DSMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  1000  	return _DSMath.Contract.contract.Transact(opts, method, params...)
  1001  }
  1002  
  1003  // DepositManagerABI is the input ABI used to generate the binding from.
  1004  const DepositManagerABI = "[{\"inputs\":[{\"internalType\":\"contractWTON\",\"name\":\"wton\",\"type\":\"address\"},{\"internalType\":\"contractRootChainRegistryI\",\"name\":\"registry\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"WITHDRAWAL_DELAY\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"depositor\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Deposited\",\"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\":\"rootchain\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"depositor\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"WithdrawalProcessed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"depositor\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"WithdrawalRequested\",\"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\":[],\"name\":\"WITHDRAWAL_DELAY\",\"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\"}],\"name\":\"accStaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accStakedAccount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"accStakedRootChain\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accUnstaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accUnstakedAccount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"accUnstakedRootChain\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"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\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"numPendingRequests\",\"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\"}],\"name\":\"numRequests\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onApprove\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"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\":\"pendingUnstaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"pendingUnstakedAccount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"pendingUnstakedRootChain\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"receiveTON\",\"type\":\"bool\"}],\"name\":\"processRequest\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"n\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"receiveTON\",\"type\":\"bool\"}],\"name\":\"processRequests\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"redeposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"n\",\"type\":\"uint256\"}],\"name\":\"redepositMulti\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"registry\",\"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\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"requestWithdrawal\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"requestWithdrawalAll\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigManager\",\"outputs\":[{\"internalType\":\"address\",\"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\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"withdrawalRequest\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"withdrawableBlockNumber\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bool\",\"name\":\"processed\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"withdrawalRequestIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"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\"}]"
  1005  
  1006  // DepositManagerFuncSigs maps the 4-byte function signature to its string representation.
  1007  var DepositManagerFuncSigs = map[string]string{
  1008  	"6cd28f9a": "INTERFACE_ID_ON_APPROVE()",
  1009  	"0ebb172a": "WITHDRAWAL_DELAY()",
  1010  	"2d2fab94": "accStaked(address,address)",
  1011  	"0055f5c1": "accStakedAccount(address)",
  1012  	"e8035ec9": "accStakedRootChain(address)",
  1013  	"9d91b87b": "accUnstaked(address,address)",
  1014  	"a3543989": "accUnstakedAccount(address)",
  1015  	"03dc6510": "accUnstakedRootChain(address)",
  1016  	"47e7ef24": "deposit(address,uint256)",
  1017  	"8f32d59b": "isOwner()",
  1018  	"5c0df46b": "numPendingRequests(address,address)",
  1019  	"f762eb57": "numRequests(address,address)",
  1020  	"4273ca16": "onApprove(address,address,uint256,bytes)",
  1021  	"8da5cb5b": "owner()",
  1022  	"2638fdf5": "pendingUnstaked(address,address)",
  1023  	"a0b2a913": "pendingUnstakedAccount(address)",
  1024  	"a8f3fb98": "pendingUnstakedRootChain(address)",
  1025  	"c20a44c6": "processRequest(address,bool)",
  1026  	"fb0713b1": "processRequests(address,uint256,bool)",
  1027  	"b8bee628": "redeposit(address)",
  1028  	"445e83b9": "redepositMulti(address,uint256)",
  1029  	"7b103999": "registry()",
  1030  	"715018a6": "renounceOwnership()",
  1031  	"da95ebf7": "requestWithdrawal(address,uint256)",
  1032  	"6b2160b7": "requestWithdrawalAll(address)",
  1033  	"6fb7f558": "seigManager()",
  1034  	"7657f20a": "setSeigManager(address)",
  1035  	"01ffc9a7": "supportsInterface(bytes4)",
  1036  	"f2fde38b": "transferOwnership(address)",
  1037  	"8fbef2d0": "withdrawalRequest(address,address,uint256)",
  1038  	"c647f26e": "withdrawalRequestIndex(address,address)",
  1039  	"8d62d949": "wton()",
  1040  }
  1041  
  1042  // DepositManagerBin is the compiled bytecode used for deploying new contracts.
  1043  var DepositManagerBin = "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"
  1044  
  1045  // DeployDepositManager deploys a new Ethereum contract, binding an instance of DepositManager to it.
  1046  func DeployDepositManager(auth *bind.TransactOpts, backend bind.ContractBackend, wton common.Address, registry common.Address, WITHDRAWAL_DELAY *big.Int) (common.Address, *types.Transaction, *DepositManager, error) {
  1047  	parsed, err := abi.JSON(strings.NewReader(DepositManagerABI))
  1048  	if err != nil {
  1049  		return common.Address{}, nil, nil, err
  1050  	}
  1051  
  1052  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(DepositManagerBin), backend, wton, registry, WITHDRAWAL_DELAY)
  1053  	if err != nil {
  1054  		return common.Address{}, nil, nil, err
  1055  	}
  1056  	return address, tx, &DepositManager{DepositManagerCaller: DepositManagerCaller{contract: contract}, DepositManagerTransactor: DepositManagerTransactor{contract: contract}, DepositManagerFilterer: DepositManagerFilterer{contract: contract}}, nil
  1057  }
  1058  
  1059  // DepositManager is an auto generated Go binding around an Ethereum contract.
  1060  type DepositManager struct {
  1061  	DepositManagerCaller     // Read-only binding to the contract
  1062  	DepositManagerTransactor // Write-only binding to the contract
  1063  	DepositManagerFilterer   // Log filterer for contract events
  1064  }
  1065  
  1066  // DepositManagerCaller is an auto generated read-only Go binding around an Ethereum contract.
  1067  type DepositManagerCaller struct {
  1068  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  1069  }
  1070  
  1071  // DepositManagerTransactor is an auto generated write-only Go binding around an Ethereum contract.
  1072  type DepositManagerTransactor struct {
  1073  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  1074  }
  1075  
  1076  // DepositManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  1077  type DepositManagerFilterer struct {
  1078  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  1079  }
  1080  
  1081  // DepositManagerSession is an auto generated Go binding around an Ethereum contract,
  1082  // with pre-set call and transact options.
  1083  type DepositManagerSession struct {
  1084  	Contract     *DepositManager   // Generic contract binding to set the session for
  1085  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  1086  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  1087  }
  1088  
  1089  // DepositManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  1090  // with pre-set call options.
  1091  type DepositManagerCallerSession struct {
  1092  	Contract *DepositManagerCaller // Generic contract caller binding to set the session for
  1093  	CallOpts bind.CallOpts         // Call options to use throughout this session
  1094  }
  1095  
  1096  // DepositManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  1097  // with pre-set transact options.
  1098  type DepositManagerTransactorSession struct {
  1099  	Contract     *DepositManagerTransactor // Generic contract transactor binding to set the session for
  1100  	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
  1101  }
  1102  
  1103  // DepositManagerRaw is an auto generated low-level Go binding around an Ethereum contract.
  1104  type DepositManagerRaw struct {
  1105  	Contract *DepositManager // Generic contract binding to access the raw methods on
  1106  }
  1107  
  1108  // DepositManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  1109  type DepositManagerCallerRaw struct {
  1110  	Contract *DepositManagerCaller // Generic read-only contract binding to access the raw methods on
  1111  }
  1112  
  1113  // DepositManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  1114  type DepositManagerTransactorRaw struct {
  1115  	Contract *DepositManagerTransactor // Generic write-only contract binding to access the raw methods on
  1116  }
  1117  
  1118  // NewDepositManager creates a new instance of DepositManager, bound to a specific deployed contract.
  1119  func NewDepositManager(address common.Address, backend bind.ContractBackend) (*DepositManager, error) {
  1120  	contract, err := bindDepositManager(address, backend, backend, backend)
  1121  	if err != nil {
  1122  		return nil, err
  1123  	}
  1124  	return &DepositManager{DepositManagerCaller: DepositManagerCaller{contract: contract}, DepositManagerTransactor: DepositManagerTransactor{contract: contract}, DepositManagerFilterer: DepositManagerFilterer{contract: contract}}, nil
  1125  }
  1126  
  1127  // NewDepositManagerCaller creates a new read-only instance of DepositManager, bound to a specific deployed contract.
  1128  func NewDepositManagerCaller(address common.Address, caller bind.ContractCaller) (*DepositManagerCaller, error) {
  1129  	contract, err := bindDepositManager(address, caller, nil, nil)
  1130  	if err != nil {
  1131  		return nil, err
  1132  	}
  1133  	return &DepositManagerCaller{contract: contract}, nil
  1134  }
  1135  
  1136  // NewDepositManagerTransactor creates a new write-only instance of DepositManager, bound to a specific deployed contract.
  1137  func NewDepositManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*DepositManagerTransactor, error) {
  1138  	contract, err := bindDepositManager(address, nil, transactor, nil)
  1139  	if err != nil {
  1140  		return nil, err
  1141  	}
  1142  	return &DepositManagerTransactor{contract: contract}, nil
  1143  }
  1144  
  1145  // NewDepositManagerFilterer creates a new log filterer instance of DepositManager, bound to a specific deployed contract.
  1146  func NewDepositManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*DepositManagerFilterer, error) {
  1147  	contract, err := bindDepositManager(address, nil, nil, filterer)
  1148  	if err != nil {
  1149  		return nil, err
  1150  	}
  1151  	return &DepositManagerFilterer{contract: contract}, nil
  1152  }
  1153  
  1154  // bindDepositManager binds a generic wrapper to an already deployed contract.
  1155  func bindDepositManager(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  1156  	parsed, err := abi.JSON(strings.NewReader(DepositManagerABI))
  1157  	if err != nil {
  1158  		return nil, err
  1159  	}
  1160  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  1161  }
  1162  
  1163  // Call invokes the (constant) contract method with params as input values and
  1164  // sets the output to result. The result type might be a single field for simple
  1165  // returns, a slice of interfaces for anonymous returns and a struct for named
  1166  // returns.
  1167  func (_DepositManager *DepositManagerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  1168  	return _DepositManager.Contract.DepositManagerCaller.contract.Call(opts, result, method, params...)
  1169  }
  1170  
  1171  // Transfer initiates a plain transaction to move funds to the contract, calling
  1172  // its default method if one is available.
  1173  func (_DepositManager *DepositManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  1174  	return _DepositManager.Contract.DepositManagerTransactor.contract.Transfer(opts)
  1175  }
  1176  
  1177  // Transact invokes the (paid) contract method with params as input values.
  1178  func (_DepositManager *DepositManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  1179  	return _DepositManager.Contract.DepositManagerTransactor.contract.Transact(opts, method, params...)
  1180  }
  1181  
  1182  // Call invokes the (constant) contract method with params as input values and
  1183  // sets the output to result. The result type might be a single field for simple
  1184  // returns, a slice of interfaces for anonymous returns and a struct for named
  1185  // returns.
  1186  func (_DepositManager *DepositManagerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  1187  	return _DepositManager.Contract.contract.Call(opts, result, method, params...)
  1188  }
  1189  
  1190  // Transfer initiates a plain transaction to move funds to the contract, calling
  1191  // its default method if one is available.
  1192  func (_DepositManager *DepositManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  1193  	return _DepositManager.Contract.contract.Transfer(opts)
  1194  }
  1195  
  1196  // Transact invokes the (paid) contract method with params as input values.
  1197  func (_DepositManager *DepositManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  1198  	return _DepositManager.Contract.contract.Transact(opts, method, params...)
  1199  }
  1200  
  1201  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  1202  //
  1203  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  1204  func (_DepositManager *DepositManagerCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) {
  1205  	var (
  1206  		ret0 = new([4]byte)
  1207  	)
  1208  	out := ret0
  1209  	err := _DepositManager.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE")
  1210  	return *ret0, err
  1211  }
  1212  
  1213  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  1214  //
  1215  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  1216  func (_DepositManager *DepositManagerSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  1217  	return _DepositManager.Contract.INTERFACEIDONAPPROVE(&_DepositManager.CallOpts)
  1218  }
  1219  
  1220  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  1221  //
  1222  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  1223  func (_DepositManager *DepositManagerCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  1224  	return _DepositManager.Contract.INTERFACEIDONAPPROVE(&_DepositManager.CallOpts)
  1225  }
  1226  
  1227  // WITHDRAWALDELAY is a free data retrieval call binding the contract method 0x0ebb172a.
  1228  //
  1229  // Solidity: function WITHDRAWAL_DELAY() constant returns(uint256)
  1230  func (_DepositManager *DepositManagerCaller) WITHDRAWALDELAY(opts *bind.CallOpts) (*big.Int, error) {
  1231  	var (
  1232  		ret0 = new(*big.Int)
  1233  	)
  1234  	out := ret0
  1235  	err := _DepositManager.contract.Call(opts, out, "WITHDRAWAL_DELAY")
  1236  	return *ret0, err
  1237  }
  1238  
  1239  // WITHDRAWALDELAY is a free data retrieval call binding the contract method 0x0ebb172a.
  1240  //
  1241  // Solidity: function WITHDRAWAL_DELAY() constant returns(uint256)
  1242  func (_DepositManager *DepositManagerSession) WITHDRAWALDELAY() (*big.Int, error) {
  1243  	return _DepositManager.Contract.WITHDRAWALDELAY(&_DepositManager.CallOpts)
  1244  }
  1245  
  1246  // WITHDRAWALDELAY is a free data retrieval call binding the contract method 0x0ebb172a.
  1247  //
  1248  // Solidity: function WITHDRAWAL_DELAY() constant returns(uint256)
  1249  func (_DepositManager *DepositManagerCallerSession) WITHDRAWALDELAY() (*big.Int, error) {
  1250  	return _DepositManager.Contract.WITHDRAWALDELAY(&_DepositManager.CallOpts)
  1251  }
  1252  
  1253  // AccStaked is a free data retrieval call binding the contract method 0x2d2fab94.
  1254  //
  1255  // Solidity: function accStaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  1256  func (_DepositManager *DepositManagerCaller) AccStaked(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
  1257  	var (
  1258  		ret0 = new(*big.Int)
  1259  	)
  1260  	out := ret0
  1261  	err := _DepositManager.contract.Call(opts, out, "accStaked", rootchain, account)
  1262  	return *ret0, err
  1263  }
  1264  
  1265  // AccStaked is a free data retrieval call binding the contract method 0x2d2fab94.
  1266  //
  1267  // Solidity: function accStaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  1268  func (_DepositManager *DepositManagerSession) AccStaked(rootchain common.Address, account common.Address) (*big.Int, error) {
  1269  	return _DepositManager.Contract.AccStaked(&_DepositManager.CallOpts, rootchain, account)
  1270  }
  1271  
  1272  // AccStaked is a free data retrieval call binding the contract method 0x2d2fab94.
  1273  //
  1274  // Solidity: function accStaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  1275  func (_DepositManager *DepositManagerCallerSession) AccStaked(rootchain common.Address, account common.Address) (*big.Int, error) {
  1276  	return _DepositManager.Contract.AccStaked(&_DepositManager.CallOpts, rootchain, account)
  1277  }
  1278  
  1279  // AccStakedAccount is a free data retrieval call binding the contract method 0x0055f5c1.
  1280  //
  1281  // Solidity: function accStakedAccount(address account) constant returns(uint256 wtonAmount)
  1282  func (_DepositManager *DepositManagerCaller) AccStakedAccount(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  1283  	var (
  1284  		ret0 = new(*big.Int)
  1285  	)
  1286  	out := ret0
  1287  	err := _DepositManager.contract.Call(opts, out, "accStakedAccount", account)
  1288  	return *ret0, err
  1289  }
  1290  
  1291  // AccStakedAccount is a free data retrieval call binding the contract method 0x0055f5c1.
  1292  //
  1293  // Solidity: function accStakedAccount(address account) constant returns(uint256 wtonAmount)
  1294  func (_DepositManager *DepositManagerSession) AccStakedAccount(account common.Address) (*big.Int, error) {
  1295  	return _DepositManager.Contract.AccStakedAccount(&_DepositManager.CallOpts, account)
  1296  }
  1297  
  1298  // AccStakedAccount is a free data retrieval call binding the contract method 0x0055f5c1.
  1299  //
  1300  // Solidity: function accStakedAccount(address account) constant returns(uint256 wtonAmount)
  1301  func (_DepositManager *DepositManagerCallerSession) AccStakedAccount(account common.Address) (*big.Int, error) {
  1302  	return _DepositManager.Contract.AccStakedAccount(&_DepositManager.CallOpts, account)
  1303  }
  1304  
  1305  // AccStakedRootChain is a free data retrieval call binding the contract method 0xe8035ec9.
  1306  //
  1307  // Solidity: function accStakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  1308  func (_DepositManager *DepositManagerCaller) AccStakedRootChain(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
  1309  	var (
  1310  		ret0 = new(*big.Int)
  1311  	)
  1312  	out := ret0
  1313  	err := _DepositManager.contract.Call(opts, out, "accStakedRootChain", rootchain)
  1314  	return *ret0, err
  1315  }
  1316  
  1317  // AccStakedRootChain is a free data retrieval call binding the contract method 0xe8035ec9.
  1318  //
  1319  // Solidity: function accStakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  1320  func (_DepositManager *DepositManagerSession) AccStakedRootChain(rootchain common.Address) (*big.Int, error) {
  1321  	return _DepositManager.Contract.AccStakedRootChain(&_DepositManager.CallOpts, rootchain)
  1322  }
  1323  
  1324  // AccStakedRootChain is a free data retrieval call binding the contract method 0xe8035ec9.
  1325  //
  1326  // Solidity: function accStakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  1327  func (_DepositManager *DepositManagerCallerSession) AccStakedRootChain(rootchain common.Address) (*big.Int, error) {
  1328  	return _DepositManager.Contract.AccStakedRootChain(&_DepositManager.CallOpts, rootchain)
  1329  }
  1330  
  1331  // AccUnstaked is a free data retrieval call binding the contract method 0x9d91b87b.
  1332  //
  1333  // Solidity: function accUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  1334  func (_DepositManager *DepositManagerCaller) AccUnstaked(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
  1335  	var (
  1336  		ret0 = new(*big.Int)
  1337  	)
  1338  	out := ret0
  1339  	err := _DepositManager.contract.Call(opts, out, "accUnstaked", rootchain, account)
  1340  	return *ret0, err
  1341  }
  1342  
  1343  // AccUnstaked is a free data retrieval call binding the contract method 0x9d91b87b.
  1344  //
  1345  // Solidity: function accUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  1346  func (_DepositManager *DepositManagerSession) AccUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) {
  1347  	return _DepositManager.Contract.AccUnstaked(&_DepositManager.CallOpts, rootchain, account)
  1348  }
  1349  
  1350  // AccUnstaked is a free data retrieval call binding the contract method 0x9d91b87b.
  1351  //
  1352  // Solidity: function accUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  1353  func (_DepositManager *DepositManagerCallerSession) AccUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) {
  1354  	return _DepositManager.Contract.AccUnstaked(&_DepositManager.CallOpts, rootchain, account)
  1355  }
  1356  
  1357  // AccUnstakedAccount is a free data retrieval call binding the contract method 0xa3543989.
  1358  //
  1359  // Solidity: function accUnstakedAccount(address account) constant returns(uint256 wtonAmount)
  1360  func (_DepositManager *DepositManagerCaller) AccUnstakedAccount(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  1361  	var (
  1362  		ret0 = new(*big.Int)
  1363  	)
  1364  	out := ret0
  1365  	err := _DepositManager.contract.Call(opts, out, "accUnstakedAccount", account)
  1366  	return *ret0, err
  1367  }
  1368  
  1369  // AccUnstakedAccount is a free data retrieval call binding the contract method 0xa3543989.
  1370  //
  1371  // Solidity: function accUnstakedAccount(address account) constant returns(uint256 wtonAmount)
  1372  func (_DepositManager *DepositManagerSession) AccUnstakedAccount(account common.Address) (*big.Int, error) {
  1373  	return _DepositManager.Contract.AccUnstakedAccount(&_DepositManager.CallOpts, account)
  1374  }
  1375  
  1376  // AccUnstakedAccount is a free data retrieval call binding the contract method 0xa3543989.
  1377  //
  1378  // Solidity: function accUnstakedAccount(address account) constant returns(uint256 wtonAmount)
  1379  func (_DepositManager *DepositManagerCallerSession) AccUnstakedAccount(account common.Address) (*big.Int, error) {
  1380  	return _DepositManager.Contract.AccUnstakedAccount(&_DepositManager.CallOpts, account)
  1381  }
  1382  
  1383  // AccUnstakedRootChain is a free data retrieval call binding the contract method 0x03dc6510.
  1384  //
  1385  // Solidity: function accUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  1386  func (_DepositManager *DepositManagerCaller) AccUnstakedRootChain(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
  1387  	var (
  1388  		ret0 = new(*big.Int)
  1389  	)
  1390  	out := ret0
  1391  	err := _DepositManager.contract.Call(opts, out, "accUnstakedRootChain", rootchain)
  1392  	return *ret0, err
  1393  }
  1394  
  1395  // AccUnstakedRootChain is a free data retrieval call binding the contract method 0x03dc6510.
  1396  //
  1397  // Solidity: function accUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  1398  func (_DepositManager *DepositManagerSession) AccUnstakedRootChain(rootchain common.Address) (*big.Int, error) {
  1399  	return _DepositManager.Contract.AccUnstakedRootChain(&_DepositManager.CallOpts, rootchain)
  1400  }
  1401  
  1402  // AccUnstakedRootChain is a free data retrieval call binding the contract method 0x03dc6510.
  1403  //
  1404  // Solidity: function accUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  1405  func (_DepositManager *DepositManagerCallerSession) AccUnstakedRootChain(rootchain common.Address) (*big.Int, error) {
  1406  	return _DepositManager.Contract.AccUnstakedRootChain(&_DepositManager.CallOpts, rootchain)
  1407  }
  1408  
  1409  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
  1410  //
  1411  // Solidity: function isOwner() constant returns(bool)
  1412  func (_DepositManager *DepositManagerCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
  1413  	var (
  1414  		ret0 = new(bool)
  1415  	)
  1416  	out := ret0
  1417  	err := _DepositManager.contract.Call(opts, out, "isOwner")
  1418  	return *ret0, err
  1419  }
  1420  
  1421  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
  1422  //
  1423  // Solidity: function isOwner() constant returns(bool)
  1424  func (_DepositManager *DepositManagerSession) IsOwner() (bool, error) {
  1425  	return _DepositManager.Contract.IsOwner(&_DepositManager.CallOpts)
  1426  }
  1427  
  1428  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
  1429  //
  1430  // Solidity: function isOwner() constant returns(bool)
  1431  func (_DepositManager *DepositManagerCallerSession) IsOwner() (bool, error) {
  1432  	return _DepositManager.Contract.IsOwner(&_DepositManager.CallOpts)
  1433  }
  1434  
  1435  // NumPendingRequests is a free data retrieval call binding the contract method 0x5c0df46b.
  1436  //
  1437  // Solidity: function numPendingRequests(address rootchain, address account) constant returns(uint256)
  1438  func (_DepositManager *DepositManagerCaller) NumPendingRequests(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
  1439  	var (
  1440  		ret0 = new(*big.Int)
  1441  	)
  1442  	out := ret0
  1443  	err := _DepositManager.contract.Call(opts, out, "numPendingRequests", rootchain, account)
  1444  	return *ret0, err
  1445  }
  1446  
  1447  // NumPendingRequests is a free data retrieval call binding the contract method 0x5c0df46b.
  1448  //
  1449  // Solidity: function numPendingRequests(address rootchain, address account) constant returns(uint256)
  1450  func (_DepositManager *DepositManagerSession) NumPendingRequests(rootchain common.Address, account common.Address) (*big.Int, error) {
  1451  	return _DepositManager.Contract.NumPendingRequests(&_DepositManager.CallOpts, rootchain, account)
  1452  }
  1453  
  1454  // NumPendingRequests is a free data retrieval call binding the contract method 0x5c0df46b.
  1455  //
  1456  // Solidity: function numPendingRequests(address rootchain, address account) constant returns(uint256)
  1457  func (_DepositManager *DepositManagerCallerSession) NumPendingRequests(rootchain common.Address, account common.Address) (*big.Int, error) {
  1458  	return _DepositManager.Contract.NumPendingRequests(&_DepositManager.CallOpts, rootchain, account)
  1459  }
  1460  
  1461  // NumRequests is a free data retrieval call binding the contract method 0xf762eb57.
  1462  //
  1463  // Solidity: function numRequests(address rootchain, address account) constant returns(uint256)
  1464  func (_DepositManager *DepositManagerCaller) NumRequests(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
  1465  	var (
  1466  		ret0 = new(*big.Int)
  1467  	)
  1468  	out := ret0
  1469  	err := _DepositManager.contract.Call(opts, out, "numRequests", rootchain, account)
  1470  	return *ret0, err
  1471  }
  1472  
  1473  // NumRequests is a free data retrieval call binding the contract method 0xf762eb57.
  1474  //
  1475  // Solidity: function numRequests(address rootchain, address account) constant returns(uint256)
  1476  func (_DepositManager *DepositManagerSession) NumRequests(rootchain common.Address, account common.Address) (*big.Int, error) {
  1477  	return _DepositManager.Contract.NumRequests(&_DepositManager.CallOpts, rootchain, account)
  1478  }
  1479  
  1480  // NumRequests is a free data retrieval call binding the contract method 0xf762eb57.
  1481  //
  1482  // Solidity: function numRequests(address rootchain, address account) constant returns(uint256)
  1483  func (_DepositManager *DepositManagerCallerSession) NumRequests(rootchain common.Address, account common.Address) (*big.Int, error) {
  1484  	return _DepositManager.Contract.NumRequests(&_DepositManager.CallOpts, rootchain, account)
  1485  }
  1486  
  1487  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  1488  //
  1489  // Solidity: function owner() constant returns(address)
  1490  func (_DepositManager *DepositManagerCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
  1491  	var (
  1492  		ret0 = new(common.Address)
  1493  	)
  1494  	out := ret0
  1495  	err := _DepositManager.contract.Call(opts, out, "owner")
  1496  	return *ret0, err
  1497  }
  1498  
  1499  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  1500  //
  1501  // Solidity: function owner() constant returns(address)
  1502  func (_DepositManager *DepositManagerSession) Owner() (common.Address, error) {
  1503  	return _DepositManager.Contract.Owner(&_DepositManager.CallOpts)
  1504  }
  1505  
  1506  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  1507  //
  1508  // Solidity: function owner() constant returns(address)
  1509  func (_DepositManager *DepositManagerCallerSession) Owner() (common.Address, error) {
  1510  	return _DepositManager.Contract.Owner(&_DepositManager.CallOpts)
  1511  }
  1512  
  1513  // PendingUnstaked is a free data retrieval call binding the contract method 0x2638fdf5.
  1514  //
  1515  // Solidity: function pendingUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  1516  func (_DepositManager *DepositManagerCaller) PendingUnstaked(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
  1517  	var (
  1518  		ret0 = new(*big.Int)
  1519  	)
  1520  	out := ret0
  1521  	err := _DepositManager.contract.Call(opts, out, "pendingUnstaked", rootchain, account)
  1522  	return *ret0, err
  1523  }
  1524  
  1525  // PendingUnstaked is a free data retrieval call binding the contract method 0x2638fdf5.
  1526  //
  1527  // Solidity: function pendingUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  1528  func (_DepositManager *DepositManagerSession) PendingUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) {
  1529  	return _DepositManager.Contract.PendingUnstaked(&_DepositManager.CallOpts, rootchain, account)
  1530  }
  1531  
  1532  // PendingUnstaked is a free data retrieval call binding the contract method 0x2638fdf5.
  1533  //
  1534  // Solidity: function pendingUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  1535  func (_DepositManager *DepositManagerCallerSession) PendingUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) {
  1536  	return _DepositManager.Contract.PendingUnstaked(&_DepositManager.CallOpts, rootchain, account)
  1537  }
  1538  
  1539  // PendingUnstakedAccount is a free data retrieval call binding the contract method 0xa0b2a913.
  1540  //
  1541  // Solidity: function pendingUnstakedAccount(address account) constant returns(uint256 wtonAmount)
  1542  func (_DepositManager *DepositManagerCaller) PendingUnstakedAccount(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  1543  	var (
  1544  		ret0 = new(*big.Int)
  1545  	)
  1546  	out := ret0
  1547  	err := _DepositManager.contract.Call(opts, out, "pendingUnstakedAccount", account)
  1548  	return *ret0, err
  1549  }
  1550  
  1551  // PendingUnstakedAccount is a free data retrieval call binding the contract method 0xa0b2a913.
  1552  //
  1553  // Solidity: function pendingUnstakedAccount(address account) constant returns(uint256 wtonAmount)
  1554  func (_DepositManager *DepositManagerSession) PendingUnstakedAccount(account common.Address) (*big.Int, error) {
  1555  	return _DepositManager.Contract.PendingUnstakedAccount(&_DepositManager.CallOpts, account)
  1556  }
  1557  
  1558  // PendingUnstakedAccount is a free data retrieval call binding the contract method 0xa0b2a913.
  1559  //
  1560  // Solidity: function pendingUnstakedAccount(address account) constant returns(uint256 wtonAmount)
  1561  func (_DepositManager *DepositManagerCallerSession) PendingUnstakedAccount(account common.Address) (*big.Int, error) {
  1562  	return _DepositManager.Contract.PendingUnstakedAccount(&_DepositManager.CallOpts, account)
  1563  }
  1564  
  1565  // PendingUnstakedRootChain is a free data retrieval call binding the contract method 0xa8f3fb98.
  1566  //
  1567  // Solidity: function pendingUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  1568  func (_DepositManager *DepositManagerCaller) PendingUnstakedRootChain(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
  1569  	var (
  1570  		ret0 = new(*big.Int)
  1571  	)
  1572  	out := ret0
  1573  	err := _DepositManager.contract.Call(opts, out, "pendingUnstakedRootChain", rootchain)
  1574  	return *ret0, err
  1575  }
  1576  
  1577  // PendingUnstakedRootChain is a free data retrieval call binding the contract method 0xa8f3fb98.
  1578  //
  1579  // Solidity: function pendingUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  1580  func (_DepositManager *DepositManagerSession) PendingUnstakedRootChain(rootchain common.Address) (*big.Int, error) {
  1581  	return _DepositManager.Contract.PendingUnstakedRootChain(&_DepositManager.CallOpts, rootchain)
  1582  }
  1583  
  1584  // PendingUnstakedRootChain is a free data retrieval call binding the contract method 0xa8f3fb98.
  1585  //
  1586  // Solidity: function pendingUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  1587  func (_DepositManager *DepositManagerCallerSession) PendingUnstakedRootChain(rootchain common.Address) (*big.Int, error) {
  1588  	return _DepositManager.Contract.PendingUnstakedRootChain(&_DepositManager.CallOpts, rootchain)
  1589  }
  1590  
  1591  // Registry is a free data retrieval call binding the contract method 0x7b103999.
  1592  //
  1593  // Solidity: function registry() constant returns(address)
  1594  func (_DepositManager *DepositManagerCaller) Registry(opts *bind.CallOpts) (common.Address, error) {
  1595  	var (
  1596  		ret0 = new(common.Address)
  1597  	)
  1598  	out := ret0
  1599  	err := _DepositManager.contract.Call(opts, out, "registry")
  1600  	return *ret0, err
  1601  }
  1602  
  1603  // Registry is a free data retrieval call binding the contract method 0x7b103999.
  1604  //
  1605  // Solidity: function registry() constant returns(address)
  1606  func (_DepositManager *DepositManagerSession) Registry() (common.Address, error) {
  1607  	return _DepositManager.Contract.Registry(&_DepositManager.CallOpts)
  1608  }
  1609  
  1610  // Registry is a free data retrieval call binding the contract method 0x7b103999.
  1611  //
  1612  // Solidity: function registry() constant returns(address)
  1613  func (_DepositManager *DepositManagerCallerSession) Registry() (common.Address, error) {
  1614  	return _DepositManager.Contract.Registry(&_DepositManager.CallOpts)
  1615  }
  1616  
  1617  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
  1618  //
  1619  // Solidity: function seigManager() constant returns(address)
  1620  func (_DepositManager *DepositManagerCaller) SeigManager(opts *bind.CallOpts) (common.Address, error) {
  1621  	var (
  1622  		ret0 = new(common.Address)
  1623  	)
  1624  	out := ret0
  1625  	err := _DepositManager.contract.Call(opts, out, "seigManager")
  1626  	return *ret0, err
  1627  }
  1628  
  1629  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
  1630  //
  1631  // Solidity: function seigManager() constant returns(address)
  1632  func (_DepositManager *DepositManagerSession) SeigManager() (common.Address, error) {
  1633  	return _DepositManager.Contract.SeigManager(&_DepositManager.CallOpts)
  1634  }
  1635  
  1636  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
  1637  //
  1638  // Solidity: function seigManager() constant returns(address)
  1639  func (_DepositManager *DepositManagerCallerSession) SeigManager() (common.Address, error) {
  1640  	return _DepositManager.Contract.SeigManager(&_DepositManager.CallOpts)
  1641  }
  1642  
  1643  // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
  1644  //
  1645  // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool)
  1646  func (_DepositManager *DepositManagerCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
  1647  	var (
  1648  		ret0 = new(bool)
  1649  	)
  1650  	out := ret0
  1651  	err := _DepositManager.contract.Call(opts, out, "supportsInterface", interfaceId)
  1652  	return *ret0, err
  1653  }
  1654  
  1655  // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
  1656  //
  1657  // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool)
  1658  func (_DepositManager *DepositManagerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
  1659  	return _DepositManager.Contract.SupportsInterface(&_DepositManager.CallOpts, interfaceId)
  1660  }
  1661  
  1662  // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
  1663  //
  1664  // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool)
  1665  func (_DepositManager *DepositManagerCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
  1666  	return _DepositManager.Contract.SupportsInterface(&_DepositManager.CallOpts, interfaceId)
  1667  }
  1668  
  1669  // WithdrawalRequest is a free data retrieval call binding the contract method 0x8fbef2d0.
  1670  //
  1671  // Solidity: function withdrawalRequest(address rootchain, address account, uint256 index) constant returns(uint128 withdrawableBlockNumber, uint128 amount, bool processed)
  1672  func (_DepositManager *DepositManagerCaller) WithdrawalRequest(opts *bind.CallOpts, rootchain common.Address, account common.Address, index *big.Int) (struct {
  1673  	WithdrawableBlockNumber *big.Int
  1674  	Amount                  *big.Int
  1675  	Processed               bool
  1676  }, error) {
  1677  	ret := new(struct {
  1678  		WithdrawableBlockNumber *big.Int
  1679  		Amount                  *big.Int
  1680  		Processed               bool
  1681  	})
  1682  	out := ret
  1683  	err := _DepositManager.contract.Call(opts, out, "withdrawalRequest", rootchain, account, index)
  1684  	return *ret, err
  1685  }
  1686  
  1687  // WithdrawalRequest is a free data retrieval call binding the contract method 0x8fbef2d0.
  1688  //
  1689  // Solidity: function withdrawalRequest(address rootchain, address account, uint256 index) constant returns(uint128 withdrawableBlockNumber, uint128 amount, bool processed)
  1690  func (_DepositManager *DepositManagerSession) WithdrawalRequest(rootchain common.Address, account common.Address, index *big.Int) (struct {
  1691  	WithdrawableBlockNumber *big.Int
  1692  	Amount                  *big.Int
  1693  	Processed               bool
  1694  }, error) {
  1695  	return _DepositManager.Contract.WithdrawalRequest(&_DepositManager.CallOpts, rootchain, account, index)
  1696  }
  1697  
  1698  // WithdrawalRequest is a free data retrieval call binding the contract method 0x8fbef2d0.
  1699  //
  1700  // Solidity: function withdrawalRequest(address rootchain, address account, uint256 index) constant returns(uint128 withdrawableBlockNumber, uint128 amount, bool processed)
  1701  func (_DepositManager *DepositManagerCallerSession) WithdrawalRequest(rootchain common.Address, account common.Address, index *big.Int) (struct {
  1702  	WithdrawableBlockNumber *big.Int
  1703  	Amount                  *big.Int
  1704  	Processed               bool
  1705  }, error) {
  1706  	return _DepositManager.Contract.WithdrawalRequest(&_DepositManager.CallOpts, rootchain, account, index)
  1707  }
  1708  
  1709  // WithdrawalRequestIndex is a free data retrieval call binding the contract method 0xc647f26e.
  1710  //
  1711  // Solidity: function withdrawalRequestIndex(address rootchain, address account) constant returns(uint256 index)
  1712  func (_DepositManager *DepositManagerCaller) WithdrawalRequestIndex(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
  1713  	var (
  1714  		ret0 = new(*big.Int)
  1715  	)
  1716  	out := ret0
  1717  	err := _DepositManager.contract.Call(opts, out, "withdrawalRequestIndex", rootchain, account)
  1718  	return *ret0, err
  1719  }
  1720  
  1721  // WithdrawalRequestIndex is a free data retrieval call binding the contract method 0xc647f26e.
  1722  //
  1723  // Solidity: function withdrawalRequestIndex(address rootchain, address account) constant returns(uint256 index)
  1724  func (_DepositManager *DepositManagerSession) WithdrawalRequestIndex(rootchain common.Address, account common.Address) (*big.Int, error) {
  1725  	return _DepositManager.Contract.WithdrawalRequestIndex(&_DepositManager.CallOpts, rootchain, account)
  1726  }
  1727  
  1728  // WithdrawalRequestIndex is a free data retrieval call binding the contract method 0xc647f26e.
  1729  //
  1730  // Solidity: function withdrawalRequestIndex(address rootchain, address account) constant returns(uint256 index)
  1731  func (_DepositManager *DepositManagerCallerSession) WithdrawalRequestIndex(rootchain common.Address, account common.Address) (*big.Int, error) {
  1732  	return _DepositManager.Contract.WithdrawalRequestIndex(&_DepositManager.CallOpts, rootchain, account)
  1733  }
  1734  
  1735  // Wton is a free data retrieval call binding the contract method 0x8d62d949.
  1736  //
  1737  // Solidity: function wton() constant returns(address)
  1738  func (_DepositManager *DepositManagerCaller) Wton(opts *bind.CallOpts) (common.Address, error) {
  1739  	var (
  1740  		ret0 = new(common.Address)
  1741  	)
  1742  	out := ret0
  1743  	err := _DepositManager.contract.Call(opts, out, "wton")
  1744  	return *ret0, err
  1745  }
  1746  
  1747  // Wton is a free data retrieval call binding the contract method 0x8d62d949.
  1748  //
  1749  // Solidity: function wton() constant returns(address)
  1750  func (_DepositManager *DepositManagerSession) Wton() (common.Address, error) {
  1751  	return _DepositManager.Contract.Wton(&_DepositManager.CallOpts)
  1752  }
  1753  
  1754  // Wton is a free data retrieval call binding the contract method 0x8d62d949.
  1755  //
  1756  // Solidity: function wton() constant returns(address)
  1757  func (_DepositManager *DepositManagerCallerSession) Wton() (common.Address, error) {
  1758  	return _DepositManager.Contract.Wton(&_DepositManager.CallOpts)
  1759  }
  1760  
  1761  // Deposit is a paid mutator transaction binding the contract method 0x47e7ef24.
  1762  //
  1763  // Solidity: function deposit(address rootchain, uint256 amount) returns(bool)
  1764  func (_DepositManager *DepositManagerTransactor) Deposit(opts *bind.TransactOpts, rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
  1765  	return _DepositManager.contract.Transact(opts, "deposit", rootchain, amount)
  1766  }
  1767  
  1768  // Deposit is a paid mutator transaction binding the contract method 0x47e7ef24.
  1769  //
  1770  // Solidity: function deposit(address rootchain, uint256 amount) returns(bool)
  1771  func (_DepositManager *DepositManagerSession) Deposit(rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
  1772  	return _DepositManager.Contract.Deposit(&_DepositManager.TransactOpts, rootchain, amount)
  1773  }
  1774  
  1775  // Deposit is a paid mutator transaction binding the contract method 0x47e7ef24.
  1776  //
  1777  // Solidity: function deposit(address rootchain, uint256 amount) returns(bool)
  1778  func (_DepositManager *DepositManagerTransactorSession) Deposit(rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
  1779  	return _DepositManager.Contract.Deposit(&_DepositManager.TransactOpts, rootchain, amount)
  1780  }
  1781  
  1782  // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16.
  1783  //
  1784  // Solidity: function onApprove(address owner, address spender, uint256 amount, bytes data) returns(bool)
  1785  func (_DepositManager *DepositManagerTransactor) OnApprove(opts *bind.TransactOpts, owner common.Address, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  1786  	return _DepositManager.contract.Transact(opts, "onApprove", owner, spender, amount, data)
  1787  }
  1788  
  1789  // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16.
  1790  //
  1791  // Solidity: function onApprove(address owner, address spender, uint256 amount, bytes data) returns(bool)
  1792  func (_DepositManager *DepositManagerSession) OnApprove(owner common.Address, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  1793  	return _DepositManager.Contract.OnApprove(&_DepositManager.TransactOpts, owner, spender, amount, data)
  1794  }
  1795  
  1796  // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16.
  1797  //
  1798  // Solidity: function onApprove(address owner, address spender, uint256 amount, bytes data) returns(bool)
  1799  func (_DepositManager *DepositManagerTransactorSession) OnApprove(owner common.Address, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  1800  	return _DepositManager.Contract.OnApprove(&_DepositManager.TransactOpts, owner, spender, amount, data)
  1801  }
  1802  
  1803  // ProcessRequest is a paid mutator transaction binding the contract method 0xc20a44c6.
  1804  //
  1805  // Solidity: function processRequest(address rootchain, bool receiveTON) returns(bool)
  1806  func (_DepositManager *DepositManagerTransactor) ProcessRequest(opts *bind.TransactOpts, rootchain common.Address, receiveTON bool) (*types.Transaction, error) {
  1807  	return _DepositManager.contract.Transact(opts, "processRequest", rootchain, receiveTON)
  1808  }
  1809  
  1810  // ProcessRequest is a paid mutator transaction binding the contract method 0xc20a44c6.
  1811  //
  1812  // Solidity: function processRequest(address rootchain, bool receiveTON) returns(bool)
  1813  func (_DepositManager *DepositManagerSession) ProcessRequest(rootchain common.Address, receiveTON bool) (*types.Transaction, error) {
  1814  	return _DepositManager.Contract.ProcessRequest(&_DepositManager.TransactOpts, rootchain, receiveTON)
  1815  }
  1816  
  1817  // ProcessRequest is a paid mutator transaction binding the contract method 0xc20a44c6.
  1818  //
  1819  // Solidity: function processRequest(address rootchain, bool receiveTON) returns(bool)
  1820  func (_DepositManager *DepositManagerTransactorSession) ProcessRequest(rootchain common.Address, receiveTON bool) (*types.Transaction, error) {
  1821  	return _DepositManager.Contract.ProcessRequest(&_DepositManager.TransactOpts, rootchain, receiveTON)
  1822  }
  1823  
  1824  // ProcessRequests is a paid mutator transaction binding the contract method 0xfb0713b1.
  1825  //
  1826  // Solidity: function processRequests(address rootchain, uint256 n, bool receiveTON) returns(bool)
  1827  func (_DepositManager *DepositManagerTransactor) ProcessRequests(opts *bind.TransactOpts, rootchain common.Address, n *big.Int, receiveTON bool) (*types.Transaction, error) {
  1828  	return _DepositManager.contract.Transact(opts, "processRequests", rootchain, n, receiveTON)
  1829  }
  1830  
  1831  // ProcessRequests is a paid mutator transaction binding the contract method 0xfb0713b1.
  1832  //
  1833  // Solidity: function processRequests(address rootchain, uint256 n, bool receiveTON) returns(bool)
  1834  func (_DepositManager *DepositManagerSession) ProcessRequests(rootchain common.Address, n *big.Int, receiveTON bool) (*types.Transaction, error) {
  1835  	return _DepositManager.Contract.ProcessRequests(&_DepositManager.TransactOpts, rootchain, n, receiveTON)
  1836  }
  1837  
  1838  // ProcessRequests is a paid mutator transaction binding the contract method 0xfb0713b1.
  1839  //
  1840  // Solidity: function processRequests(address rootchain, uint256 n, bool receiveTON) returns(bool)
  1841  func (_DepositManager *DepositManagerTransactorSession) ProcessRequests(rootchain common.Address, n *big.Int, receiveTON bool) (*types.Transaction, error) {
  1842  	return _DepositManager.Contract.ProcessRequests(&_DepositManager.TransactOpts, rootchain, n, receiveTON)
  1843  }
  1844  
  1845  // Redeposit is a paid mutator transaction binding the contract method 0xb8bee628.
  1846  //
  1847  // Solidity: function redeposit(address rootchain) returns(bool)
  1848  func (_DepositManager *DepositManagerTransactor) Redeposit(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) {
  1849  	return _DepositManager.contract.Transact(opts, "redeposit", rootchain)
  1850  }
  1851  
  1852  // Redeposit is a paid mutator transaction binding the contract method 0xb8bee628.
  1853  //
  1854  // Solidity: function redeposit(address rootchain) returns(bool)
  1855  func (_DepositManager *DepositManagerSession) Redeposit(rootchain common.Address) (*types.Transaction, error) {
  1856  	return _DepositManager.Contract.Redeposit(&_DepositManager.TransactOpts, rootchain)
  1857  }
  1858  
  1859  // Redeposit is a paid mutator transaction binding the contract method 0xb8bee628.
  1860  //
  1861  // Solidity: function redeposit(address rootchain) returns(bool)
  1862  func (_DepositManager *DepositManagerTransactorSession) Redeposit(rootchain common.Address) (*types.Transaction, error) {
  1863  	return _DepositManager.Contract.Redeposit(&_DepositManager.TransactOpts, rootchain)
  1864  }
  1865  
  1866  // RedepositMulti is a paid mutator transaction binding the contract method 0x445e83b9.
  1867  //
  1868  // Solidity: function redepositMulti(address rootchain, uint256 n) returns(bool)
  1869  func (_DepositManager *DepositManagerTransactor) RedepositMulti(opts *bind.TransactOpts, rootchain common.Address, n *big.Int) (*types.Transaction, error) {
  1870  	return _DepositManager.contract.Transact(opts, "redepositMulti", rootchain, n)
  1871  }
  1872  
  1873  // RedepositMulti is a paid mutator transaction binding the contract method 0x445e83b9.
  1874  //
  1875  // Solidity: function redepositMulti(address rootchain, uint256 n) returns(bool)
  1876  func (_DepositManager *DepositManagerSession) RedepositMulti(rootchain common.Address, n *big.Int) (*types.Transaction, error) {
  1877  	return _DepositManager.Contract.RedepositMulti(&_DepositManager.TransactOpts, rootchain, n)
  1878  }
  1879  
  1880  // RedepositMulti is a paid mutator transaction binding the contract method 0x445e83b9.
  1881  //
  1882  // Solidity: function redepositMulti(address rootchain, uint256 n) returns(bool)
  1883  func (_DepositManager *DepositManagerTransactorSession) RedepositMulti(rootchain common.Address, n *big.Int) (*types.Transaction, error) {
  1884  	return _DepositManager.Contract.RedepositMulti(&_DepositManager.TransactOpts, rootchain, n)
  1885  }
  1886  
  1887  // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
  1888  //
  1889  // Solidity: function renounceOwnership() returns()
  1890  func (_DepositManager *DepositManagerTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
  1891  	return _DepositManager.contract.Transact(opts, "renounceOwnership")
  1892  }
  1893  
  1894  // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
  1895  //
  1896  // Solidity: function renounceOwnership() returns()
  1897  func (_DepositManager *DepositManagerSession) RenounceOwnership() (*types.Transaction, error) {
  1898  	return _DepositManager.Contract.RenounceOwnership(&_DepositManager.TransactOpts)
  1899  }
  1900  
  1901  // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
  1902  //
  1903  // Solidity: function renounceOwnership() returns()
  1904  func (_DepositManager *DepositManagerTransactorSession) RenounceOwnership() (*types.Transaction, error) {
  1905  	return _DepositManager.Contract.RenounceOwnership(&_DepositManager.TransactOpts)
  1906  }
  1907  
  1908  // RequestWithdrawal is a paid mutator transaction binding the contract method 0xda95ebf7.
  1909  //
  1910  // Solidity: function requestWithdrawal(address rootchain, uint256 amount) returns(bool)
  1911  func (_DepositManager *DepositManagerTransactor) RequestWithdrawal(opts *bind.TransactOpts, rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
  1912  	return _DepositManager.contract.Transact(opts, "requestWithdrawal", rootchain, amount)
  1913  }
  1914  
  1915  // RequestWithdrawal is a paid mutator transaction binding the contract method 0xda95ebf7.
  1916  //
  1917  // Solidity: function requestWithdrawal(address rootchain, uint256 amount) returns(bool)
  1918  func (_DepositManager *DepositManagerSession) RequestWithdrawal(rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
  1919  	return _DepositManager.Contract.RequestWithdrawal(&_DepositManager.TransactOpts, rootchain, amount)
  1920  }
  1921  
  1922  // RequestWithdrawal is a paid mutator transaction binding the contract method 0xda95ebf7.
  1923  //
  1924  // Solidity: function requestWithdrawal(address rootchain, uint256 amount) returns(bool)
  1925  func (_DepositManager *DepositManagerTransactorSession) RequestWithdrawal(rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
  1926  	return _DepositManager.Contract.RequestWithdrawal(&_DepositManager.TransactOpts, rootchain, amount)
  1927  }
  1928  
  1929  // RequestWithdrawalAll is a paid mutator transaction binding the contract method 0x6b2160b7.
  1930  //
  1931  // Solidity: function requestWithdrawalAll(address rootchain) returns(bool)
  1932  func (_DepositManager *DepositManagerTransactor) RequestWithdrawalAll(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) {
  1933  	return _DepositManager.contract.Transact(opts, "requestWithdrawalAll", rootchain)
  1934  }
  1935  
  1936  // RequestWithdrawalAll is a paid mutator transaction binding the contract method 0x6b2160b7.
  1937  //
  1938  // Solidity: function requestWithdrawalAll(address rootchain) returns(bool)
  1939  func (_DepositManager *DepositManagerSession) RequestWithdrawalAll(rootchain common.Address) (*types.Transaction, error) {
  1940  	return _DepositManager.Contract.RequestWithdrawalAll(&_DepositManager.TransactOpts, rootchain)
  1941  }
  1942  
  1943  // RequestWithdrawalAll is a paid mutator transaction binding the contract method 0x6b2160b7.
  1944  //
  1945  // Solidity: function requestWithdrawalAll(address rootchain) returns(bool)
  1946  func (_DepositManager *DepositManagerTransactorSession) RequestWithdrawalAll(rootchain common.Address) (*types.Transaction, error) {
  1947  	return _DepositManager.Contract.RequestWithdrawalAll(&_DepositManager.TransactOpts, rootchain)
  1948  }
  1949  
  1950  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
  1951  //
  1952  // Solidity: function setSeigManager(address seigManager) returns()
  1953  func (_DepositManager *DepositManagerTransactor) SetSeigManager(opts *bind.TransactOpts, seigManager common.Address) (*types.Transaction, error) {
  1954  	return _DepositManager.contract.Transact(opts, "setSeigManager", seigManager)
  1955  }
  1956  
  1957  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
  1958  //
  1959  // Solidity: function setSeigManager(address seigManager) returns()
  1960  func (_DepositManager *DepositManagerSession) SetSeigManager(seigManager common.Address) (*types.Transaction, error) {
  1961  	return _DepositManager.Contract.SetSeigManager(&_DepositManager.TransactOpts, seigManager)
  1962  }
  1963  
  1964  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
  1965  //
  1966  // Solidity: function setSeigManager(address seigManager) returns()
  1967  func (_DepositManager *DepositManagerTransactorSession) SetSeigManager(seigManager common.Address) (*types.Transaction, error) {
  1968  	return _DepositManager.Contract.SetSeigManager(&_DepositManager.TransactOpts, seigManager)
  1969  }
  1970  
  1971  // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
  1972  //
  1973  // Solidity: function transferOwnership(address newOwner) returns()
  1974  func (_DepositManager *DepositManagerTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
  1975  	return _DepositManager.contract.Transact(opts, "transferOwnership", newOwner)
  1976  }
  1977  
  1978  // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
  1979  //
  1980  // Solidity: function transferOwnership(address newOwner) returns()
  1981  func (_DepositManager *DepositManagerSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
  1982  	return _DepositManager.Contract.TransferOwnership(&_DepositManager.TransactOpts, newOwner)
  1983  }
  1984  
  1985  // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
  1986  //
  1987  // Solidity: function transferOwnership(address newOwner) returns()
  1988  func (_DepositManager *DepositManagerTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
  1989  	return _DepositManager.Contract.TransferOwnership(&_DepositManager.TransactOpts, newOwner)
  1990  }
  1991  
  1992  // DepositManagerDepositedIterator is returned from FilterDeposited and is used to iterate over the raw logs and unpacked data for Deposited events raised by the DepositManager contract.
  1993  type DepositManagerDepositedIterator struct {
  1994  	Event *DepositManagerDeposited // Event containing the contract specifics and raw log
  1995  
  1996  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  1997  	event    string              // Event name to use for unpacking event data
  1998  
  1999  	logs chan types.Log        // Log channel receiving the found contract events
  2000  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  2001  	done bool                  // Whether the subscription completed delivering logs
  2002  	fail error                 // Occurred error to stop iteration
  2003  }
  2004  
  2005  // Next advances the iterator to the subsequent event, returning whether there
  2006  // are any more events found. In case of a retrieval or parsing error, false is
  2007  // returned and Error() can be queried for the exact failure.
  2008  func (it *DepositManagerDepositedIterator) Next() bool {
  2009  	// If the iterator failed, stop iterating
  2010  	if it.fail != nil {
  2011  		return false
  2012  	}
  2013  	// If the iterator completed, deliver directly whatever's available
  2014  	if it.done {
  2015  		select {
  2016  		case log := <-it.logs:
  2017  			it.Event = new(DepositManagerDeposited)
  2018  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2019  				it.fail = err
  2020  				return false
  2021  			}
  2022  			it.Event.Raw = log
  2023  			return true
  2024  
  2025  		default:
  2026  			return false
  2027  		}
  2028  	}
  2029  	// Iterator still in progress, wait for either a data or an error event
  2030  	select {
  2031  	case log := <-it.logs:
  2032  		it.Event = new(DepositManagerDeposited)
  2033  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2034  			it.fail = err
  2035  			return false
  2036  		}
  2037  		it.Event.Raw = log
  2038  		return true
  2039  
  2040  	case err := <-it.sub.Err():
  2041  		it.done = true
  2042  		it.fail = err
  2043  		return it.Next()
  2044  	}
  2045  }
  2046  
  2047  // Error returns any retrieval or parsing error occurred during filtering.
  2048  func (it *DepositManagerDepositedIterator) Error() error {
  2049  	return it.fail
  2050  }
  2051  
  2052  // Close terminates the iteration process, releasing any pending underlying
  2053  // resources.
  2054  func (it *DepositManagerDepositedIterator) Close() error {
  2055  	it.sub.Unsubscribe()
  2056  	return nil
  2057  }
  2058  
  2059  // DepositManagerDeposited represents a Deposited event raised by the DepositManager contract.
  2060  type DepositManagerDeposited struct {
  2061  	Rootchain common.Address
  2062  	Depositor common.Address
  2063  	Amount    *big.Int
  2064  	Raw       types.Log // Blockchain specific contextual infos
  2065  }
  2066  
  2067  // FilterDeposited is a free log retrieval operation binding the contract event 0x8752a472e571a816aea92eec8dae9baf628e840f4929fbcc2d155e6233ff68a7.
  2068  //
  2069  // Solidity: event Deposited(address indexed rootchain, address depositor, uint256 amount)
  2070  func (_DepositManager *DepositManagerFilterer) FilterDeposited(opts *bind.FilterOpts, rootchain []common.Address) (*DepositManagerDepositedIterator, error) {
  2071  
  2072  	var rootchainRule []interface{}
  2073  	for _, rootchainItem := range rootchain {
  2074  		rootchainRule = append(rootchainRule, rootchainItem)
  2075  	}
  2076  
  2077  	logs, sub, err := _DepositManager.contract.FilterLogs(opts, "Deposited", rootchainRule)
  2078  	if err != nil {
  2079  		return nil, err
  2080  	}
  2081  	return &DepositManagerDepositedIterator{contract: _DepositManager.contract, event: "Deposited", logs: logs, sub: sub}, nil
  2082  }
  2083  
  2084  // WatchDeposited is a free log subscription operation binding the contract event 0x8752a472e571a816aea92eec8dae9baf628e840f4929fbcc2d155e6233ff68a7.
  2085  //
  2086  // Solidity: event Deposited(address indexed rootchain, address depositor, uint256 amount)
  2087  func (_DepositManager *DepositManagerFilterer) WatchDeposited(opts *bind.WatchOpts, sink chan<- *DepositManagerDeposited, rootchain []common.Address) (event.Subscription, error) {
  2088  
  2089  	var rootchainRule []interface{}
  2090  	for _, rootchainItem := range rootchain {
  2091  		rootchainRule = append(rootchainRule, rootchainItem)
  2092  	}
  2093  
  2094  	logs, sub, err := _DepositManager.contract.WatchLogs(opts, "Deposited", rootchainRule)
  2095  	if err != nil {
  2096  		return nil, err
  2097  	}
  2098  	return event.NewSubscription(func(quit <-chan struct{}) error {
  2099  		defer sub.Unsubscribe()
  2100  		for {
  2101  			select {
  2102  			case log := <-logs:
  2103  				// New log arrived, parse the event and forward to the user
  2104  				event := new(DepositManagerDeposited)
  2105  				if err := _DepositManager.contract.UnpackLog(event, "Deposited", log); err != nil {
  2106  					return err
  2107  				}
  2108  				event.Raw = log
  2109  
  2110  				select {
  2111  				case sink <- event:
  2112  				case err := <-sub.Err():
  2113  					return err
  2114  				case <-quit:
  2115  					return nil
  2116  				}
  2117  			case err := <-sub.Err():
  2118  				return err
  2119  			case <-quit:
  2120  				return nil
  2121  			}
  2122  		}
  2123  	}), nil
  2124  }
  2125  
  2126  // ParseDeposited is a log parse operation binding the contract event 0x8752a472e571a816aea92eec8dae9baf628e840f4929fbcc2d155e6233ff68a7.
  2127  //
  2128  // Solidity: event Deposited(address indexed rootchain, address depositor, uint256 amount)
  2129  func (_DepositManager *DepositManagerFilterer) ParseDeposited(log types.Log) (*DepositManagerDeposited, error) {
  2130  	event := new(DepositManagerDeposited)
  2131  	if err := _DepositManager.contract.UnpackLog(event, "Deposited", log); err != nil {
  2132  		return nil, err
  2133  	}
  2134  	return event, nil
  2135  }
  2136  
  2137  // DepositManagerOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the DepositManager contract.
  2138  type DepositManagerOwnershipTransferredIterator struct {
  2139  	Event *DepositManagerOwnershipTransferred // Event containing the contract specifics and raw log
  2140  
  2141  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  2142  	event    string              // Event name to use for unpacking event data
  2143  
  2144  	logs chan types.Log        // Log channel receiving the found contract events
  2145  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  2146  	done bool                  // Whether the subscription completed delivering logs
  2147  	fail error                 // Occurred error to stop iteration
  2148  }
  2149  
  2150  // Next advances the iterator to the subsequent event, returning whether there
  2151  // are any more events found. In case of a retrieval or parsing error, false is
  2152  // returned and Error() can be queried for the exact failure.
  2153  func (it *DepositManagerOwnershipTransferredIterator) Next() bool {
  2154  	// If the iterator failed, stop iterating
  2155  	if it.fail != nil {
  2156  		return false
  2157  	}
  2158  	// If the iterator completed, deliver directly whatever's available
  2159  	if it.done {
  2160  		select {
  2161  		case log := <-it.logs:
  2162  			it.Event = new(DepositManagerOwnershipTransferred)
  2163  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2164  				it.fail = err
  2165  				return false
  2166  			}
  2167  			it.Event.Raw = log
  2168  			return true
  2169  
  2170  		default:
  2171  			return false
  2172  		}
  2173  	}
  2174  	// Iterator still in progress, wait for either a data or an error event
  2175  	select {
  2176  	case log := <-it.logs:
  2177  		it.Event = new(DepositManagerOwnershipTransferred)
  2178  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2179  			it.fail = err
  2180  			return false
  2181  		}
  2182  		it.Event.Raw = log
  2183  		return true
  2184  
  2185  	case err := <-it.sub.Err():
  2186  		it.done = true
  2187  		it.fail = err
  2188  		return it.Next()
  2189  	}
  2190  }
  2191  
  2192  // Error returns any retrieval or parsing error occurred during filtering.
  2193  func (it *DepositManagerOwnershipTransferredIterator) Error() error {
  2194  	return it.fail
  2195  }
  2196  
  2197  // Close terminates the iteration process, releasing any pending underlying
  2198  // resources.
  2199  func (it *DepositManagerOwnershipTransferredIterator) Close() error {
  2200  	it.sub.Unsubscribe()
  2201  	return nil
  2202  }
  2203  
  2204  // DepositManagerOwnershipTransferred represents a OwnershipTransferred event raised by the DepositManager contract.
  2205  type DepositManagerOwnershipTransferred struct {
  2206  	PreviousOwner common.Address
  2207  	NewOwner      common.Address
  2208  	Raw           types.Log // Blockchain specific contextual infos
  2209  }
  2210  
  2211  // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
  2212  //
  2213  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
  2214  func (_DepositManager *DepositManagerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*DepositManagerOwnershipTransferredIterator, error) {
  2215  
  2216  	var previousOwnerRule []interface{}
  2217  	for _, previousOwnerItem := range previousOwner {
  2218  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
  2219  	}
  2220  	var newOwnerRule []interface{}
  2221  	for _, newOwnerItem := range newOwner {
  2222  		newOwnerRule = append(newOwnerRule, newOwnerItem)
  2223  	}
  2224  
  2225  	logs, sub, err := _DepositManager.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
  2226  	if err != nil {
  2227  		return nil, err
  2228  	}
  2229  	return &DepositManagerOwnershipTransferredIterator{contract: _DepositManager.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
  2230  }
  2231  
  2232  // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
  2233  //
  2234  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
  2235  func (_DepositManager *DepositManagerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *DepositManagerOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {
  2236  
  2237  	var previousOwnerRule []interface{}
  2238  	for _, previousOwnerItem := range previousOwner {
  2239  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
  2240  	}
  2241  	var newOwnerRule []interface{}
  2242  	for _, newOwnerItem := range newOwner {
  2243  		newOwnerRule = append(newOwnerRule, newOwnerItem)
  2244  	}
  2245  
  2246  	logs, sub, err := _DepositManager.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
  2247  	if err != nil {
  2248  		return nil, err
  2249  	}
  2250  	return event.NewSubscription(func(quit <-chan struct{}) error {
  2251  		defer sub.Unsubscribe()
  2252  		for {
  2253  			select {
  2254  			case log := <-logs:
  2255  				// New log arrived, parse the event and forward to the user
  2256  				event := new(DepositManagerOwnershipTransferred)
  2257  				if err := _DepositManager.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
  2258  					return err
  2259  				}
  2260  				event.Raw = log
  2261  
  2262  				select {
  2263  				case sink <- event:
  2264  				case err := <-sub.Err():
  2265  					return err
  2266  				case <-quit:
  2267  					return nil
  2268  				}
  2269  			case err := <-sub.Err():
  2270  				return err
  2271  			case <-quit:
  2272  				return nil
  2273  			}
  2274  		}
  2275  	}), nil
  2276  }
  2277  
  2278  // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
  2279  //
  2280  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
  2281  func (_DepositManager *DepositManagerFilterer) ParseOwnershipTransferred(log types.Log) (*DepositManagerOwnershipTransferred, error) {
  2282  	event := new(DepositManagerOwnershipTransferred)
  2283  	if err := _DepositManager.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
  2284  		return nil, err
  2285  	}
  2286  	return event, nil
  2287  }
  2288  
  2289  // DepositManagerWithdrawalProcessedIterator is returned from FilterWithdrawalProcessed and is used to iterate over the raw logs and unpacked data for WithdrawalProcessed events raised by the DepositManager contract.
  2290  type DepositManagerWithdrawalProcessedIterator struct {
  2291  	Event *DepositManagerWithdrawalProcessed // Event containing the contract specifics and raw log
  2292  
  2293  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  2294  	event    string              // Event name to use for unpacking event data
  2295  
  2296  	logs chan types.Log        // Log channel receiving the found contract events
  2297  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  2298  	done bool                  // Whether the subscription completed delivering logs
  2299  	fail error                 // Occurred error to stop iteration
  2300  }
  2301  
  2302  // Next advances the iterator to the subsequent event, returning whether there
  2303  // are any more events found. In case of a retrieval or parsing error, false is
  2304  // returned and Error() can be queried for the exact failure.
  2305  func (it *DepositManagerWithdrawalProcessedIterator) Next() bool {
  2306  	// If the iterator failed, stop iterating
  2307  	if it.fail != nil {
  2308  		return false
  2309  	}
  2310  	// If the iterator completed, deliver directly whatever's available
  2311  	if it.done {
  2312  		select {
  2313  		case log := <-it.logs:
  2314  			it.Event = new(DepositManagerWithdrawalProcessed)
  2315  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2316  				it.fail = err
  2317  				return false
  2318  			}
  2319  			it.Event.Raw = log
  2320  			return true
  2321  
  2322  		default:
  2323  			return false
  2324  		}
  2325  	}
  2326  	// Iterator still in progress, wait for either a data or an error event
  2327  	select {
  2328  	case log := <-it.logs:
  2329  		it.Event = new(DepositManagerWithdrawalProcessed)
  2330  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2331  			it.fail = err
  2332  			return false
  2333  		}
  2334  		it.Event.Raw = log
  2335  		return true
  2336  
  2337  	case err := <-it.sub.Err():
  2338  		it.done = true
  2339  		it.fail = err
  2340  		return it.Next()
  2341  	}
  2342  }
  2343  
  2344  // Error returns any retrieval or parsing error occurred during filtering.
  2345  func (it *DepositManagerWithdrawalProcessedIterator) Error() error {
  2346  	return it.fail
  2347  }
  2348  
  2349  // Close terminates the iteration process, releasing any pending underlying
  2350  // resources.
  2351  func (it *DepositManagerWithdrawalProcessedIterator) Close() error {
  2352  	it.sub.Unsubscribe()
  2353  	return nil
  2354  }
  2355  
  2356  // DepositManagerWithdrawalProcessed represents a WithdrawalProcessed event raised by the DepositManager contract.
  2357  type DepositManagerWithdrawalProcessed struct {
  2358  	Rootchain common.Address
  2359  	Depositor common.Address
  2360  	Amount    *big.Int
  2361  	Raw       types.Log // Blockchain specific contextual infos
  2362  }
  2363  
  2364  // FilterWithdrawalProcessed is a free log retrieval operation binding the contract event 0xcd1fce47d5ad89dd70b04c75bd6bdb8114d4d4ff7b4393f9fb5937e733ba9582.
  2365  //
  2366  // Solidity: event WithdrawalProcessed(address indexed rootchain, address depositor, uint256 amount)
  2367  func (_DepositManager *DepositManagerFilterer) FilterWithdrawalProcessed(opts *bind.FilterOpts, rootchain []common.Address) (*DepositManagerWithdrawalProcessedIterator, error) {
  2368  
  2369  	var rootchainRule []interface{}
  2370  	for _, rootchainItem := range rootchain {
  2371  		rootchainRule = append(rootchainRule, rootchainItem)
  2372  	}
  2373  
  2374  	logs, sub, err := _DepositManager.contract.FilterLogs(opts, "WithdrawalProcessed", rootchainRule)
  2375  	if err != nil {
  2376  		return nil, err
  2377  	}
  2378  	return &DepositManagerWithdrawalProcessedIterator{contract: _DepositManager.contract, event: "WithdrawalProcessed", logs: logs, sub: sub}, nil
  2379  }
  2380  
  2381  // WatchWithdrawalProcessed is a free log subscription operation binding the contract event 0xcd1fce47d5ad89dd70b04c75bd6bdb8114d4d4ff7b4393f9fb5937e733ba9582.
  2382  //
  2383  // Solidity: event WithdrawalProcessed(address indexed rootchain, address depositor, uint256 amount)
  2384  func (_DepositManager *DepositManagerFilterer) WatchWithdrawalProcessed(opts *bind.WatchOpts, sink chan<- *DepositManagerWithdrawalProcessed, rootchain []common.Address) (event.Subscription, error) {
  2385  
  2386  	var rootchainRule []interface{}
  2387  	for _, rootchainItem := range rootchain {
  2388  		rootchainRule = append(rootchainRule, rootchainItem)
  2389  	}
  2390  
  2391  	logs, sub, err := _DepositManager.contract.WatchLogs(opts, "WithdrawalProcessed", rootchainRule)
  2392  	if err != nil {
  2393  		return nil, err
  2394  	}
  2395  	return event.NewSubscription(func(quit <-chan struct{}) error {
  2396  		defer sub.Unsubscribe()
  2397  		for {
  2398  			select {
  2399  			case log := <-logs:
  2400  				// New log arrived, parse the event and forward to the user
  2401  				event := new(DepositManagerWithdrawalProcessed)
  2402  				if err := _DepositManager.contract.UnpackLog(event, "WithdrawalProcessed", log); err != nil {
  2403  					return err
  2404  				}
  2405  				event.Raw = log
  2406  
  2407  				select {
  2408  				case sink <- event:
  2409  				case err := <-sub.Err():
  2410  					return err
  2411  				case <-quit:
  2412  					return nil
  2413  				}
  2414  			case err := <-sub.Err():
  2415  				return err
  2416  			case <-quit:
  2417  				return nil
  2418  			}
  2419  		}
  2420  	}), nil
  2421  }
  2422  
  2423  // ParseWithdrawalProcessed is a log parse operation binding the contract event 0xcd1fce47d5ad89dd70b04c75bd6bdb8114d4d4ff7b4393f9fb5937e733ba9582.
  2424  //
  2425  // Solidity: event WithdrawalProcessed(address indexed rootchain, address depositor, uint256 amount)
  2426  func (_DepositManager *DepositManagerFilterer) ParseWithdrawalProcessed(log types.Log) (*DepositManagerWithdrawalProcessed, error) {
  2427  	event := new(DepositManagerWithdrawalProcessed)
  2428  	if err := _DepositManager.contract.UnpackLog(event, "WithdrawalProcessed", log); err != nil {
  2429  		return nil, err
  2430  	}
  2431  	return event, nil
  2432  }
  2433  
  2434  // DepositManagerWithdrawalRequestedIterator is returned from FilterWithdrawalRequested and is used to iterate over the raw logs and unpacked data for WithdrawalRequested events raised by the DepositManager contract.
  2435  type DepositManagerWithdrawalRequestedIterator struct {
  2436  	Event *DepositManagerWithdrawalRequested // Event containing the contract specifics and raw log
  2437  
  2438  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  2439  	event    string              // Event name to use for unpacking event data
  2440  
  2441  	logs chan types.Log        // Log channel receiving the found contract events
  2442  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  2443  	done bool                  // Whether the subscription completed delivering logs
  2444  	fail error                 // Occurred error to stop iteration
  2445  }
  2446  
  2447  // Next advances the iterator to the subsequent event, returning whether there
  2448  // are any more events found. In case of a retrieval or parsing error, false is
  2449  // returned and Error() can be queried for the exact failure.
  2450  func (it *DepositManagerWithdrawalRequestedIterator) Next() bool {
  2451  	// If the iterator failed, stop iterating
  2452  	if it.fail != nil {
  2453  		return false
  2454  	}
  2455  	// If the iterator completed, deliver directly whatever's available
  2456  	if it.done {
  2457  		select {
  2458  		case log := <-it.logs:
  2459  			it.Event = new(DepositManagerWithdrawalRequested)
  2460  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2461  				it.fail = err
  2462  				return false
  2463  			}
  2464  			it.Event.Raw = log
  2465  			return true
  2466  
  2467  		default:
  2468  			return false
  2469  		}
  2470  	}
  2471  	// Iterator still in progress, wait for either a data or an error event
  2472  	select {
  2473  	case log := <-it.logs:
  2474  		it.Event = new(DepositManagerWithdrawalRequested)
  2475  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  2476  			it.fail = err
  2477  			return false
  2478  		}
  2479  		it.Event.Raw = log
  2480  		return true
  2481  
  2482  	case err := <-it.sub.Err():
  2483  		it.done = true
  2484  		it.fail = err
  2485  		return it.Next()
  2486  	}
  2487  }
  2488  
  2489  // Error returns any retrieval or parsing error occurred during filtering.
  2490  func (it *DepositManagerWithdrawalRequestedIterator) Error() error {
  2491  	return it.fail
  2492  }
  2493  
  2494  // Close terminates the iteration process, releasing any pending underlying
  2495  // resources.
  2496  func (it *DepositManagerWithdrawalRequestedIterator) Close() error {
  2497  	it.sub.Unsubscribe()
  2498  	return nil
  2499  }
  2500  
  2501  // DepositManagerWithdrawalRequested represents a WithdrawalRequested event raised by the DepositManager contract.
  2502  type DepositManagerWithdrawalRequested struct {
  2503  	Rootchain common.Address
  2504  	Depositor common.Address
  2505  	Amount    *big.Int
  2506  	Raw       types.Log // Blockchain specific contextual infos
  2507  }
  2508  
  2509  // FilterWithdrawalRequested is a free log retrieval operation binding the contract event 0x04c56a409d50971e45c5a2d96e5d557d2b0f1d66d40f14b141e4c958b0f39b32.
  2510  //
  2511  // Solidity: event WithdrawalRequested(address indexed rootchain, address depositor, uint256 amount)
  2512  func (_DepositManager *DepositManagerFilterer) FilterWithdrawalRequested(opts *bind.FilterOpts, rootchain []common.Address) (*DepositManagerWithdrawalRequestedIterator, error) {
  2513  
  2514  	var rootchainRule []interface{}
  2515  	for _, rootchainItem := range rootchain {
  2516  		rootchainRule = append(rootchainRule, rootchainItem)
  2517  	}
  2518  
  2519  	logs, sub, err := _DepositManager.contract.FilterLogs(opts, "WithdrawalRequested", rootchainRule)
  2520  	if err != nil {
  2521  		return nil, err
  2522  	}
  2523  	return &DepositManagerWithdrawalRequestedIterator{contract: _DepositManager.contract, event: "WithdrawalRequested", logs: logs, sub: sub}, nil
  2524  }
  2525  
  2526  // WatchWithdrawalRequested is a free log subscription operation binding the contract event 0x04c56a409d50971e45c5a2d96e5d557d2b0f1d66d40f14b141e4c958b0f39b32.
  2527  //
  2528  // Solidity: event WithdrawalRequested(address indexed rootchain, address depositor, uint256 amount)
  2529  func (_DepositManager *DepositManagerFilterer) WatchWithdrawalRequested(opts *bind.WatchOpts, sink chan<- *DepositManagerWithdrawalRequested, rootchain []common.Address) (event.Subscription, error) {
  2530  
  2531  	var rootchainRule []interface{}
  2532  	for _, rootchainItem := range rootchain {
  2533  		rootchainRule = append(rootchainRule, rootchainItem)
  2534  	}
  2535  
  2536  	logs, sub, err := _DepositManager.contract.WatchLogs(opts, "WithdrawalRequested", rootchainRule)
  2537  	if err != nil {
  2538  		return nil, err
  2539  	}
  2540  	return event.NewSubscription(func(quit <-chan struct{}) error {
  2541  		defer sub.Unsubscribe()
  2542  		for {
  2543  			select {
  2544  			case log := <-logs:
  2545  				// New log arrived, parse the event and forward to the user
  2546  				event := new(DepositManagerWithdrawalRequested)
  2547  				if err := _DepositManager.contract.UnpackLog(event, "WithdrawalRequested", log); err != nil {
  2548  					return err
  2549  				}
  2550  				event.Raw = log
  2551  
  2552  				select {
  2553  				case sink <- event:
  2554  				case err := <-sub.Err():
  2555  					return err
  2556  				case <-quit:
  2557  					return nil
  2558  				}
  2559  			case err := <-sub.Err():
  2560  				return err
  2561  			case <-quit:
  2562  				return nil
  2563  			}
  2564  		}
  2565  	}), nil
  2566  }
  2567  
  2568  // ParseWithdrawalRequested is a log parse operation binding the contract event 0x04c56a409d50971e45c5a2d96e5d557d2b0f1d66d40f14b141e4c958b0f39b32.
  2569  //
  2570  // Solidity: event WithdrawalRequested(address indexed rootchain, address depositor, uint256 amount)
  2571  func (_DepositManager *DepositManagerFilterer) ParseWithdrawalRequested(log types.Log) (*DepositManagerWithdrawalRequested, error) {
  2572  	event := new(DepositManagerWithdrawalRequested)
  2573  	if err := _DepositManager.contract.UnpackLog(event, "WithdrawalRequested", log); err != nil {
  2574  		return nil, err
  2575  	}
  2576  	return event, nil
  2577  }
  2578  
  2579  // DepositManagerIABI is the input ABI used to generate the binding from.
  2580  const DepositManagerIABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"WITHDRAWAL_DELAY\",\"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\"}],\"name\":\"accStaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accStakedAccount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"accStakedRootChain\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accUnstaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accUnstakedAccount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"accUnstakedRootChain\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"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\":\"numPendingRequests\",\"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\"}],\"name\":\"numRequests\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"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\":\"pendingUnstaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"pendingUnstakedAccount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"pendingUnstakedRootChain\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"processRequest\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"n\",\"type\":\"uint256\"}],\"name\":\"processRequests\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"requestWithdrawal\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"requestWithdrawalAll\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"seigManager\",\"type\":\"address\"}],\"name\":\"setSeigManager\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"withdrawalRequest\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"withdrawableBlockNumber\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bool\",\"name\":\"processed\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"withdrawalRequestIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"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\"}]"
  2581  
  2582  // DepositManagerIFuncSigs maps the 4-byte function signature to its string representation.
  2583  var DepositManagerIFuncSigs = map[string]string{
  2584  	"0ebb172a": "WITHDRAWAL_DELAY()",
  2585  	"2d2fab94": "accStaked(address,address)",
  2586  	"0055f5c1": "accStakedAccount(address)",
  2587  	"e8035ec9": "accStakedRootChain(address)",
  2588  	"9d91b87b": "accUnstaked(address,address)",
  2589  	"a3543989": "accUnstakedAccount(address)",
  2590  	"03dc6510": "accUnstakedRootChain(address)",
  2591  	"47e7ef24": "deposit(address,uint256)",
  2592  	"5c0df46b": "numPendingRequests(address,address)",
  2593  	"f762eb57": "numRequests(address,address)",
  2594  	"8da5cb5b": "owner()",
  2595  	"2638fdf5": "pendingUnstaked(address,address)",
  2596  	"a0b2a913": "pendingUnstakedAccount(address)",
  2597  	"a8f3fb98": "pendingUnstakedRootChain(address)",
  2598  	"5d6f7cca": "processRequest(address)",
  2599  	"06260ceb": "processRequests(address,uint256)",
  2600  	"7b103999": "registry()",
  2601  	"da95ebf7": "requestWithdrawal(address,uint256)",
  2602  	"6b2160b7": "requestWithdrawalAll(address)",
  2603  	"6fb7f558": "seigManager()",
  2604  	"7657f20a": "setSeigManager(address)",
  2605  	"8fbef2d0": "withdrawalRequest(address,address,uint256)",
  2606  	"c647f26e": "withdrawalRequestIndex(address,address)",
  2607  	"8d62d949": "wton()",
  2608  }
  2609  
  2610  // DepositManagerI is an auto generated Go binding around an Ethereum contract.
  2611  type DepositManagerI struct {
  2612  	DepositManagerICaller     // Read-only binding to the contract
  2613  	DepositManagerITransactor // Write-only binding to the contract
  2614  	DepositManagerIFilterer   // Log filterer for contract events
  2615  }
  2616  
  2617  // DepositManagerICaller is an auto generated read-only Go binding around an Ethereum contract.
  2618  type DepositManagerICaller struct {
  2619  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  2620  }
  2621  
  2622  // DepositManagerITransactor is an auto generated write-only Go binding around an Ethereum contract.
  2623  type DepositManagerITransactor struct {
  2624  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  2625  }
  2626  
  2627  // DepositManagerIFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  2628  type DepositManagerIFilterer struct {
  2629  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  2630  }
  2631  
  2632  // DepositManagerISession is an auto generated Go binding around an Ethereum contract,
  2633  // with pre-set call and transact options.
  2634  type DepositManagerISession struct {
  2635  	Contract     *DepositManagerI  // Generic contract binding to set the session for
  2636  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  2637  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  2638  }
  2639  
  2640  // DepositManagerICallerSession is an auto generated read-only Go binding around an Ethereum contract,
  2641  // with pre-set call options.
  2642  type DepositManagerICallerSession struct {
  2643  	Contract *DepositManagerICaller // Generic contract caller binding to set the session for
  2644  	CallOpts bind.CallOpts          // Call options to use throughout this session
  2645  }
  2646  
  2647  // DepositManagerITransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  2648  // with pre-set transact options.
  2649  type DepositManagerITransactorSession struct {
  2650  	Contract     *DepositManagerITransactor // Generic contract transactor binding to set the session for
  2651  	TransactOpts bind.TransactOpts          // Transaction auth options to use throughout this session
  2652  }
  2653  
  2654  // DepositManagerIRaw is an auto generated low-level Go binding around an Ethereum contract.
  2655  type DepositManagerIRaw struct {
  2656  	Contract *DepositManagerI // Generic contract binding to access the raw methods on
  2657  }
  2658  
  2659  // DepositManagerICallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  2660  type DepositManagerICallerRaw struct {
  2661  	Contract *DepositManagerICaller // Generic read-only contract binding to access the raw methods on
  2662  }
  2663  
  2664  // DepositManagerITransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  2665  type DepositManagerITransactorRaw struct {
  2666  	Contract *DepositManagerITransactor // Generic write-only contract binding to access the raw methods on
  2667  }
  2668  
  2669  // NewDepositManagerI creates a new instance of DepositManagerI, bound to a specific deployed contract.
  2670  func NewDepositManagerI(address common.Address, backend bind.ContractBackend) (*DepositManagerI, error) {
  2671  	contract, err := bindDepositManagerI(address, backend, backend, backend)
  2672  	if err != nil {
  2673  		return nil, err
  2674  	}
  2675  	return &DepositManagerI{DepositManagerICaller: DepositManagerICaller{contract: contract}, DepositManagerITransactor: DepositManagerITransactor{contract: contract}, DepositManagerIFilterer: DepositManagerIFilterer{contract: contract}}, nil
  2676  }
  2677  
  2678  // NewDepositManagerICaller creates a new read-only instance of DepositManagerI, bound to a specific deployed contract.
  2679  func NewDepositManagerICaller(address common.Address, caller bind.ContractCaller) (*DepositManagerICaller, error) {
  2680  	contract, err := bindDepositManagerI(address, caller, nil, nil)
  2681  	if err != nil {
  2682  		return nil, err
  2683  	}
  2684  	return &DepositManagerICaller{contract: contract}, nil
  2685  }
  2686  
  2687  // NewDepositManagerITransactor creates a new write-only instance of DepositManagerI, bound to a specific deployed contract.
  2688  func NewDepositManagerITransactor(address common.Address, transactor bind.ContractTransactor) (*DepositManagerITransactor, error) {
  2689  	contract, err := bindDepositManagerI(address, nil, transactor, nil)
  2690  	if err != nil {
  2691  		return nil, err
  2692  	}
  2693  	return &DepositManagerITransactor{contract: contract}, nil
  2694  }
  2695  
  2696  // NewDepositManagerIFilterer creates a new log filterer instance of DepositManagerI, bound to a specific deployed contract.
  2697  func NewDepositManagerIFilterer(address common.Address, filterer bind.ContractFilterer) (*DepositManagerIFilterer, error) {
  2698  	contract, err := bindDepositManagerI(address, nil, nil, filterer)
  2699  	if err != nil {
  2700  		return nil, err
  2701  	}
  2702  	return &DepositManagerIFilterer{contract: contract}, nil
  2703  }
  2704  
  2705  // bindDepositManagerI binds a generic wrapper to an already deployed contract.
  2706  func bindDepositManagerI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  2707  	parsed, err := abi.JSON(strings.NewReader(DepositManagerIABI))
  2708  	if err != nil {
  2709  		return nil, err
  2710  	}
  2711  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  2712  }
  2713  
  2714  // Call invokes the (constant) contract method with params as input values and
  2715  // sets the output to result. The result type might be a single field for simple
  2716  // returns, a slice of interfaces for anonymous returns and a struct for named
  2717  // returns.
  2718  func (_DepositManagerI *DepositManagerIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  2719  	return _DepositManagerI.Contract.DepositManagerICaller.contract.Call(opts, result, method, params...)
  2720  }
  2721  
  2722  // Transfer initiates a plain transaction to move funds to the contract, calling
  2723  // its default method if one is available.
  2724  func (_DepositManagerI *DepositManagerIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  2725  	return _DepositManagerI.Contract.DepositManagerITransactor.contract.Transfer(opts)
  2726  }
  2727  
  2728  // Transact invokes the (paid) contract method with params as input values.
  2729  func (_DepositManagerI *DepositManagerIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  2730  	return _DepositManagerI.Contract.DepositManagerITransactor.contract.Transact(opts, method, params...)
  2731  }
  2732  
  2733  // Call invokes the (constant) contract method with params as input values and
  2734  // sets the output to result. The result type might be a single field for simple
  2735  // returns, a slice of interfaces for anonymous returns and a struct for named
  2736  // returns.
  2737  func (_DepositManagerI *DepositManagerICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  2738  	return _DepositManagerI.Contract.contract.Call(opts, result, method, params...)
  2739  }
  2740  
  2741  // Transfer initiates a plain transaction to move funds to the contract, calling
  2742  // its default method if one is available.
  2743  func (_DepositManagerI *DepositManagerITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  2744  	return _DepositManagerI.Contract.contract.Transfer(opts)
  2745  }
  2746  
  2747  // Transact invokes the (paid) contract method with params as input values.
  2748  func (_DepositManagerI *DepositManagerITransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  2749  	return _DepositManagerI.Contract.contract.Transact(opts, method, params...)
  2750  }
  2751  
  2752  // WITHDRAWALDELAY is a free data retrieval call binding the contract method 0x0ebb172a.
  2753  //
  2754  // Solidity: function WITHDRAWAL_DELAY() constant returns(uint256)
  2755  func (_DepositManagerI *DepositManagerICaller) WITHDRAWALDELAY(opts *bind.CallOpts) (*big.Int, error) {
  2756  	var (
  2757  		ret0 = new(*big.Int)
  2758  	)
  2759  	out := ret0
  2760  	err := _DepositManagerI.contract.Call(opts, out, "WITHDRAWAL_DELAY")
  2761  	return *ret0, err
  2762  }
  2763  
  2764  // WITHDRAWALDELAY is a free data retrieval call binding the contract method 0x0ebb172a.
  2765  //
  2766  // Solidity: function WITHDRAWAL_DELAY() constant returns(uint256)
  2767  func (_DepositManagerI *DepositManagerISession) WITHDRAWALDELAY() (*big.Int, error) {
  2768  	return _DepositManagerI.Contract.WITHDRAWALDELAY(&_DepositManagerI.CallOpts)
  2769  }
  2770  
  2771  // WITHDRAWALDELAY is a free data retrieval call binding the contract method 0x0ebb172a.
  2772  //
  2773  // Solidity: function WITHDRAWAL_DELAY() constant returns(uint256)
  2774  func (_DepositManagerI *DepositManagerICallerSession) WITHDRAWALDELAY() (*big.Int, error) {
  2775  	return _DepositManagerI.Contract.WITHDRAWALDELAY(&_DepositManagerI.CallOpts)
  2776  }
  2777  
  2778  // AccStaked is a free data retrieval call binding the contract method 0x2d2fab94.
  2779  //
  2780  // Solidity: function accStaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  2781  func (_DepositManagerI *DepositManagerICaller) AccStaked(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
  2782  	var (
  2783  		ret0 = new(*big.Int)
  2784  	)
  2785  	out := ret0
  2786  	err := _DepositManagerI.contract.Call(opts, out, "accStaked", rootchain, account)
  2787  	return *ret0, err
  2788  }
  2789  
  2790  // AccStaked is a free data retrieval call binding the contract method 0x2d2fab94.
  2791  //
  2792  // Solidity: function accStaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  2793  func (_DepositManagerI *DepositManagerISession) AccStaked(rootchain common.Address, account common.Address) (*big.Int, error) {
  2794  	return _DepositManagerI.Contract.AccStaked(&_DepositManagerI.CallOpts, rootchain, account)
  2795  }
  2796  
  2797  // AccStaked is a free data retrieval call binding the contract method 0x2d2fab94.
  2798  //
  2799  // Solidity: function accStaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  2800  func (_DepositManagerI *DepositManagerICallerSession) AccStaked(rootchain common.Address, account common.Address) (*big.Int, error) {
  2801  	return _DepositManagerI.Contract.AccStaked(&_DepositManagerI.CallOpts, rootchain, account)
  2802  }
  2803  
  2804  // AccStakedAccount is a free data retrieval call binding the contract method 0x0055f5c1.
  2805  //
  2806  // Solidity: function accStakedAccount(address account) constant returns(uint256 wtonAmount)
  2807  func (_DepositManagerI *DepositManagerICaller) AccStakedAccount(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  2808  	var (
  2809  		ret0 = new(*big.Int)
  2810  	)
  2811  	out := ret0
  2812  	err := _DepositManagerI.contract.Call(opts, out, "accStakedAccount", account)
  2813  	return *ret0, err
  2814  }
  2815  
  2816  // AccStakedAccount is a free data retrieval call binding the contract method 0x0055f5c1.
  2817  //
  2818  // Solidity: function accStakedAccount(address account) constant returns(uint256 wtonAmount)
  2819  func (_DepositManagerI *DepositManagerISession) AccStakedAccount(account common.Address) (*big.Int, error) {
  2820  	return _DepositManagerI.Contract.AccStakedAccount(&_DepositManagerI.CallOpts, account)
  2821  }
  2822  
  2823  // AccStakedAccount is a free data retrieval call binding the contract method 0x0055f5c1.
  2824  //
  2825  // Solidity: function accStakedAccount(address account) constant returns(uint256 wtonAmount)
  2826  func (_DepositManagerI *DepositManagerICallerSession) AccStakedAccount(account common.Address) (*big.Int, error) {
  2827  	return _DepositManagerI.Contract.AccStakedAccount(&_DepositManagerI.CallOpts, account)
  2828  }
  2829  
  2830  // AccStakedRootChain is a free data retrieval call binding the contract method 0xe8035ec9.
  2831  //
  2832  // Solidity: function accStakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  2833  func (_DepositManagerI *DepositManagerICaller) AccStakedRootChain(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
  2834  	var (
  2835  		ret0 = new(*big.Int)
  2836  	)
  2837  	out := ret0
  2838  	err := _DepositManagerI.contract.Call(opts, out, "accStakedRootChain", rootchain)
  2839  	return *ret0, err
  2840  }
  2841  
  2842  // AccStakedRootChain is a free data retrieval call binding the contract method 0xe8035ec9.
  2843  //
  2844  // Solidity: function accStakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  2845  func (_DepositManagerI *DepositManagerISession) AccStakedRootChain(rootchain common.Address) (*big.Int, error) {
  2846  	return _DepositManagerI.Contract.AccStakedRootChain(&_DepositManagerI.CallOpts, rootchain)
  2847  }
  2848  
  2849  // AccStakedRootChain is a free data retrieval call binding the contract method 0xe8035ec9.
  2850  //
  2851  // Solidity: function accStakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  2852  func (_DepositManagerI *DepositManagerICallerSession) AccStakedRootChain(rootchain common.Address) (*big.Int, error) {
  2853  	return _DepositManagerI.Contract.AccStakedRootChain(&_DepositManagerI.CallOpts, rootchain)
  2854  }
  2855  
  2856  // AccUnstaked is a free data retrieval call binding the contract method 0x9d91b87b.
  2857  //
  2858  // Solidity: function accUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  2859  func (_DepositManagerI *DepositManagerICaller) AccUnstaked(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
  2860  	var (
  2861  		ret0 = new(*big.Int)
  2862  	)
  2863  	out := ret0
  2864  	err := _DepositManagerI.contract.Call(opts, out, "accUnstaked", rootchain, account)
  2865  	return *ret0, err
  2866  }
  2867  
  2868  // AccUnstaked is a free data retrieval call binding the contract method 0x9d91b87b.
  2869  //
  2870  // Solidity: function accUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  2871  func (_DepositManagerI *DepositManagerISession) AccUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) {
  2872  	return _DepositManagerI.Contract.AccUnstaked(&_DepositManagerI.CallOpts, rootchain, account)
  2873  }
  2874  
  2875  // AccUnstaked is a free data retrieval call binding the contract method 0x9d91b87b.
  2876  //
  2877  // Solidity: function accUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  2878  func (_DepositManagerI *DepositManagerICallerSession) AccUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) {
  2879  	return _DepositManagerI.Contract.AccUnstaked(&_DepositManagerI.CallOpts, rootchain, account)
  2880  }
  2881  
  2882  // AccUnstakedAccount is a free data retrieval call binding the contract method 0xa3543989.
  2883  //
  2884  // Solidity: function accUnstakedAccount(address account) constant returns(uint256 wtonAmount)
  2885  func (_DepositManagerI *DepositManagerICaller) AccUnstakedAccount(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  2886  	var (
  2887  		ret0 = new(*big.Int)
  2888  	)
  2889  	out := ret0
  2890  	err := _DepositManagerI.contract.Call(opts, out, "accUnstakedAccount", account)
  2891  	return *ret0, err
  2892  }
  2893  
  2894  // AccUnstakedAccount is a free data retrieval call binding the contract method 0xa3543989.
  2895  //
  2896  // Solidity: function accUnstakedAccount(address account) constant returns(uint256 wtonAmount)
  2897  func (_DepositManagerI *DepositManagerISession) AccUnstakedAccount(account common.Address) (*big.Int, error) {
  2898  	return _DepositManagerI.Contract.AccUnstakedAccount(&_DepositManagerI.CallOpts, account)
  2899  }
  2900  
  2901  // AccUnstakedAccount is a free data retrieval call binding the contract method 0xa3543989.
  2902  //
  2903  // Solidity: function accUnstakedAccount(address account) constant returns(uint256 wtonAmount)
  2904  func (_DepositManagerI *DepositManagerICallerSession) AccUnstakedAccount(account common.Address) (*big.Int, error) {
  2905  	return _DepositManagerI.Contract.AccUnstakedAccount(&_DepositManagerI.CallOpts, account)
  2906  }
  2907  
  2908  // AccUnstakedRootChain is a free data retrieval call binding the contract method 0x03dc6510.
  2909  //
  2910  // Solidity: function accUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  2911  func (_DepositManagerI *DepositManagerICaller) AccUnstakedRootChain(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
  2912  	var (
  2913  		ret0 = new(*big.Int)
  2914  	)
  2915  	out := ret0
  2916  	err := _DepositManagerI.contract.Call(opts, out, "accUnstakedRootChain", rootchain)
  2917  	return *ret0, err
  2918  }
  2919  
  2920  // AccUnstakedRootChain is a free data retrieval call binding the contract method 0x03dc6510.
  2921  //
  2922  // Solidity: function accUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  2923  func (_DepositManagerI *DepositManagerISession) AccUnstakedRootChain(rootchain common.Address) (*big.Int, error) {
  2924  	return _DepositManagerI.Contract.AccUnstakedRootChain(&_DepositManagerI.CallOpts, rootchain)
  2925  }
  2926  
  2927  // AccUnstakedRootChain is a free data retrieval call binding the contract method 0x03dc6510.
  2928  //
  2929  // Solidity: function accUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  2930  func (_DepositManagerI *DepositManagerICallerSession) AccUnstakedRootChain(rootchain common.Address) (*big.Int, error) {
  2931  	return _DepositManagerI.Contract.AccUnstakedRootChain(&_DepositManagerI.CallOpts, rootchain)
  2932  }
  2933  
  2934  // NumPendingRequests is a free data retrieval call binding the contract method 0x5c0df46b.
  2935  //
  2936  // Solidity: function numPendingRequests(address rootchain, address account) constant returns(uint256)
  2937  func (_DepositManagerI *DepositManagerICaller) NumPendingRequests(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
  2938  	var (
  2939  		ret0 = new(*big.Int)
  2940  	)
  2941  	out := ret0
  2942  	err := _DepositManagerI.contract.Call(opts, out, "numPendingRequests", rootchain, account)
  2943  	return *ret0, err
  2944  }
  2945  
  2946  // NumPendingRequests is a free data retrieval call binding the contract method 0x5c0df46b.
  2947  //
  2948  // Solidity: function numPendingRequests(address rootchain, address account) constant returns(uint256)
  2949  func (_DepositManagerI *DepositManagerISession) NumPendingRequests(rootchain common.Address, account common.Address) (*big.Int, error) {
  2950  	return _DepositManagerI.Contract.NumPendingRequests(&_DepositManagerI.CallOpts, rootchain, account)
  2951  }
  2952  
  2953  // NumPendingRequests is a free data retrieval call binding the contract method 0x5c0df46b.
  2954  //
  2955  // Solidity: function numPendingRequests(address rootchain, address account) constant returns(uint256)
  2956  func (_DepositManagerI *DepositManagerICallerSession) NumPendingRequests(rootchain common.Address, account common.Address) (*big.Int, error) {
  2957  	return _DepositManagerI.Contract.NumPendingRequests(&_DepositManagerI.CallOpts, rootchain, account)
  2958  }
  2959  
  2960  // NumRequests is a free data retrieval call binding the contract method 0xf762eb57.
  2961  //
  2962  // Solidity: function numRequests(address rootchain, address account) constant returns(uint256)
  2963  func (_DepositManagerI *DepositManagerICaller) NumRequests(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
  2964  	var (
  2965  		ret0 = new(*big.Int)
  2966  	)
  2967  	out := ret0
  2968  	err := _DepositManagerI.contract.Call(opts, out, "numRequests", rootchain, account)
  2969  	return *ret0, err
  2970  }
  2971  
  2972  // NumRequests is a free data retrieval call binding the contract method 0xf762eb57.
  2973  //
  2974  // Solidity: function numRequests(address rootchain, address account) constant returns(uint256)
  2975  func (_DepositManagerI *DepositManagerISession) NumRequests(rootchain common.Address, account common.Address) (*big.Int, error) {
  2976  	return _DepositManagerI.Contract.NumRequests(&_DepositManagerI.CallOpts, rootchain, account)
  2977  }
  2978  
  2979  // NumRequests is a free data retrieval call binding the contract method 0xf762eb57.
  2980  //
  2981  // Solidity: function numRequests(address rootchain, address account) constant returns(uint256)
  2982  func (_DepositManagerI *DepositManagerICallerSession) NumRequests(rootchain common.Address, account common.Address) (*big.Int, error) {
  2983  	return _DepositManagerI.Contract.NumRequests(&_DepositManagerI.CallOpts, rootchain, account)
  2984  }
  2985  
  2986  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  2987  //
  2988  // Solidity: function owner() constant returns(address)
  2989  func (_DepositManagerI *DepositManagerICaller) Owner(opts *bind.CallOpts) (common.Address, error) {
  2990  	var (
  2991  		ret0 = new(common.Address)
  2992  	)
  2993  	out := ret0
  2994  	err := _DepositManagerI.contract.Call(opts, out, "owner")
  2995  	return *ret0, err
  2996  }
  2997  
  2998  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  2999  //
  3000  // Solidity: function owner() constant returns(address)
  3001  func (_DepositManagerI *DepositManagerISession) Owner() (common.Address, error) {
  3002  	return _DepositManagerI.Contract.Owner(&_DepositManagerI.CallOpts)
  3003  }
  3004  
  3005  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  3006  //
  3007  // Solidity: function owner() constant returns(address)
  3008  func (_DepositManagerI *DepositManagerICallerSession) Owner() (common.Address, error) {
  3009  	return _DepositManagerI.Contract.Owner(&_DepositManagerI.CallOpts)
  3010  }
  3011  
  3012  // PendingUnstaked is a free data retrieval call binding the contract method 0x2638fdf5.
  3013  //
  3014  // Solidity: function pendingUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  3015  func (_DepositManagerI *DepositManagerICaller) PendingUnstaked(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
  3016  	var (
  3017  		ret0 = new(*big.Int)
  3018  	)
  3019  	out := ret0
  3020  	err := _DepositManagerI.contract.Call(opts, out, "pendingUnstaked", rootchain, account)
  3021  	return *ret0, err
  3022  }
  3023  
  3024  // PendingUnstaked is a free data retrieval call binding the contract method 0x2638fdf5.
  3025  //
  3026  // Solidity: function pendingUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  3027  func (_DepositManagerI *DepositManagerISession) PendingUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) {
  3028  	return _DepositManagerI.Contract.PendingUnstaked(&_DepositManagerI.CallOpts, rootchain, account)
  3029  }
  3030  
  3031  // PendingUnstaked is a free data retrieval call binding the contract method 0x2638fdf5.
  3032  //
  3033  // Solidity: function pendingUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount)
  3034  func (_DepositManagerI *DepositManagerICallerSession) PendingUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) {
  3035  	return _DepositManagerI.Contract.PendingUnstaked(&_DepositManagerI.CallOpts, rootchain, account)
  3036  }
  3037  
  3038  // PendingUnstakedAccount is a free data retrieval call binding the contract method 0xa0b2a913.
  3039  //
  3040  // Solidity: function pendingUnstakedAccount(address account) constant returns(uint256 wtonAmount)
  3041  func (_DepositManagerI *DepositManagerICaller) PendingUnstakedAccount(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  3042  	var (
  3043  		ret0 = new(*big.Int)
  3044  	)
  3045  	out := ret0
  3046  	err := _DepositManagerI.contract.Call(opts, out, "pendingUnstakedAccount", account)
  3047  	return *ret0, err
  3048  }
  3049  
  3050  // PendingUnstakedAccount is a free data retrieval call binding the contract method 0xa0b2a913.
  3051  //
  3052  // Solidity: function pendingUnstakedAccount(address account) constant returns(uint256 wtonAmount)
  3053  func (_DepositManagerI *DepositManagerISession) PendingUnstakedAccount(account common.Address) (*big.Int, error) {
  3054  	return _DepositManagerI.Contract.PendingUnstakedAccount(&_DepositManagerI.CallOpts, account)
  3055  }
  3056  
  3057  // PendingUnstakedAccount is a free data retrieval call binding the contract method 0xa0b2a913.
  3058  //
  3059  // Solidity: function pendingUnstakedAccount(address account) constant returns(uint256 wtonAmount)
  3060  func (_DepositManagerI *DepositManagerICallerSession) PendingUnstakedAccount(account common.Address) (*big.Int, error) {
  3061  	return _DepositManagerI.Contract.PendingUnstakedAccount(&_DepositManagerI.CallOpts, account)
  3062  }
  3063  
  3064  // PendingUnstakedRootChain is a free data retrieval call binding the contract method 0xa8f3fb98.
  3065  //
  3066  // Solidity: function pendingUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  3067  func (_DepositManagerI *DepositManagerICaller) PendingUnstakedRootChain(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
  3068  	var (
  3069  		ret0 = new(*big.Int)
  3070  	)
  3071  	out := ret0
  3072  	err := _DepositManagerI.contract.Call(opts, out, "pendingUnstakedRootChain", rootchain)
  3073  	return *ret0, err
  3074  }
  3075  
  3076  // PendingUnstakedRootChain is a free data retrieval call binding the contract method 0xa8f3fb98.
  3077  //
  3078  // Solidity: function pendingUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  3079  func (_DepositManagerI *DepositManagerISession) PendingUnstakedRootChain(rootchain common.Address) (*big.Int, error) {
  3080  	return _DepositManagerI.Contract.PendingUnstakedRootChain(&_DepositManagerI.CallOpts, rootchain)
  3081  }
  3082  
  3083  // PendingUnstakedRootChain is a free data retrieval call binding the contract method 0xa8f3fb98.
  3084  //
  3085  // Solidity: function pendingUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount)
  3086  func (_DepositManagerI *DepositManagerICallerSession) PendingUnstakedRootChain(rootchain common.Address) (*big.Int, error) {
  3087  	return _DepositManagerI.Contract.PendingUnstakedRootChain(&_DepositManagerI.CallOpts, rootchain)
  3088  }
  3089  
  3090  // Registry is a free data retrieval call binding the contract method 0x7b103999.
  3091  //
  3092  // Solidity: function registry() constant returns(address)
  3093  func (_DepositManagerI *DepositManagerICaller) Registry(opts *bind.CallOpts) (common.Address, error) {
  3094  	var (
  3095  		ret0 = new(common.Address)
  3096  	)
  3097  	out := ret0
  3098  	err := _DepositManagerI.contract.Call(opts, out, "registry")
  3099  	return *ret0, err
  3100  }
  3101  
  3102  // Registry is a free data retrieval call binding the contract method 0x7b103999.
  3103  //
  3104  // Solidity: function registry() constant returns(address)
  3105  func (_DepositManagerI *DepositManagerISession) Registry() (common.Address, error) {
  3106  	return _DepositManagerI.Contract.Registry(&_DepositManagerI.CallOpts)
  3107  }
  3108  
  3109  // Registry is a free data retrieval call binding the contract method 0x7b103999.
  3110  //
  3111  // Solidity: function registry() constant returns(address)
  3112  func (_DepositManagerI *DepositManagerICallerSession) Registry() (common.Address, error) {
  3113  	return _DepositManagerI.Contract.Registry(&_DepositManagerI.CallOpts)
  3114  }
  3115  
  3116  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
  3117  //
  3118  // Solidity: function seigManager() constant returns(address)
  3119  func (_DepositManagerI *DepositManagerICaller) SeigManager(opts *bind.CallOpts) (common.Address, error) {
  3120  	var (
  3121  		ret0 = new(common.Address)
  3122  	)
  3123  	out := ret0
  3124  	err := _DepositManagerI.contract.Call(opts, out, "seigManager")
  3125  	return *ret0, err
  3126  }
  3127  
  3128  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
  3129  //
  3130  // Solidity: function seigManager() constant returns(address)
  3131  func (_DepositManagerI *DepositManagerISession) SeigManager() (common.Address, error) {
  3132  	return _DepositManagerI.Contract.SeigManager(&_DepositManagerI.CallOpts)
  3133  }
  3134  
  3135  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
  3136  //
  3137  // Solidity: function seigManager() constant returns(address)
  3138  func (_DepositManagerI *DepositManagerICallerSession) SeigManager() (common.Address, error) {
  3139  	return _DepositManagerI.Contract.SeigManager(&_DepositManagerI.CallOpts)
  3140  }
  3141  
  3142  // WithdrawalRequest is a free data retrieval call binding the contract method 0x8fbef2d0.
  3143  //
  3144  // Solidity: function withdrawalRequest(address rootchain, address account, uint256 index) constant returns(uint128 withdrawableBlockNumber, uint128 amount, bool processed)
  3145  func (_DepositManagerI *DepositManagerICaller) WithdrawalRequest(opts *bind.CallOpts, rootchain common.Address, account common.Address, index *big.Int) (struct {
  3146  	WithdrawableBlockNumber *big.Int
  3147  	Amount                  *big.Int
  3148  	Processed               bool
  3149  }, error) {
  3150  	ret := new(struct {
  3151  		WithdrawableBlockNumber *big.Int
  3152  		Amount                  *big.Int
  3153  		Processed               bool
  3154  	})
  3155  	out := ret
  3156  	err := _DepositManagerI.contract.Call(opts, out, "withdrawalRequest", rootchain, account, index)
  3157  	return *ret, err
  3158  }
  3159  
  3160  // WithdrawalRequest is a free data retrieval call binding the contract method 0x8fbef2d0.
  3161  //
  3162  // Solidity: function withdrawalRequest(address rootchain, address account, uint256 index) constant returns(uint128 withdrawableBlockNumber, uint128 amount, bool processed)
  3163  func (_DepositManagerI *DepositManagerISession) WithdrawalRequest(rootchain common.Address, account common.Address, index *big.Int) (struct {
  3164  	WithdrawableBlockNumber *big.Int
  3165  	Amount                  *big.Int
  3166  	Processed               bool
  3167  }, error) {
  3168  	return _DepositManagerI.Contract.WithdrawalRequest(&_DepositManagerI.CallOpts, rootchain, account, index)
  3169  }
  3170  
  3171  // WithdrawalRequest is a free data retrieval call binding the contract method 0x8fbef2d0.
  3172  //
  3173  // Solidity: function withdrawalRequest(address rootchain, address account, uint256 index) constant returns(uint128 withdrawableBlockNumber, uint128 amount, bool processed)
  3174  func (_DepositManagerI *DepositManagerICallerSession) WithdrawalRequest(rootchain common.Address, account common.Address, index *big.Int) (struct {
  3175  	WithdrawableBlockNumber *big.Int
  3176  	Amount                  *big.Int
  3177  	Processed               bool
  3178  }, error) {
  3179  	return _DepositManagerI.Contract.WithdrawalRequest(&_DepositManagerI.CallOpts, rootchain, account, index)
  3180  }
  3181  
  3182  // WithdrawalRequestIndex is a free data retrieval call binding the contract method 0xc647f26e.
  3183  //
  3184  // Solidity: function withdrawalRequestIndex(address rootchain, address account) constant returns(uint256 index)
  3185  func (_DepositManagerI *DepositManagerICaller) WithdrawalRequestIndex(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
  3186  	var (
  3187  		ret0 = new(*big.Int)
  3188  	)
  3189  	out := ret0
  3190  	err := _DepositManagerI.contract.Call(opts, out, "withdrawalRequestIndex", rootchain, account)
  3191  	return *ret0, err
  3192  }
  3193  
  3194  // WithdrawalRequestIndex is a free data retrieval call binding the contract method 0xc647f26e.
  3195  //
  3196  // Solidity: function withdrawalRequestIndex(address rootchain, address account) constant returns(uint256 index)
  3197  func (_DepositManagerI *DepositManagerISession) WithdrawalRequestIndex(rootchain common.Address, account common.Address) (*big.Int, error) {
  3198  	return _DepositManagerI.Contract.WithdrawalRequestIndex(&_DepositManagerI.CallOpts, rootchain, account)
  3199  }
  3200  
  3201  // WithdrawalRequestIndex is a free data retrieval call binding the contract method 0xc647f26e.
  3202  //
  3203  // Solidity: function withdrawalRequestIndex(address rootchain, address account) constant returns(uint256 index)
  3204  func (_DepositManagerI *DepositManagerICallerSession) WithdrawalRequestIndex(rootchain common.Address, account common.Address) (*big.Int, error) {
  3205  	return _DepositManagerI.Contract.WithdrawalRequestIndex(&_DepositManagerI.CallOpts, rootchain, account)
  3206  }
  3207  
  3208  // Wton is a free data retrieval call binding the contract method 0x8d62d949.
  3209  //
  3210  // Solidity: function wton() constant returns(address)
  3211  func (_DepositManagerI *DepositManagerICaller) Wton(opts *bind.CallOpts) (common.Address, error) {
  3212  	var (
  3213  		ret0 = new(common.Address)
  3214  	)
  3215  	out := ret0
  3216  	err := _DepositManagerI.contract.Call(opts, out, "wton")
  3217  	return *ret0, err
  3218  }
  3219  
  3220  // Wton is a free data retrieval call binding the contract method 0x8d62d949.
  3221  //
  3222  // Solidity: function wton() constant returns(address)
  3223  func (_DepositManagerI *DepositManagerISession) Wton() (common.Address, error) {
  3224  	return _DepositManagerI.Contract.Wton(&_DepositManagerI.CallOpts)
  3225  }
  3226  
  3227  // Wton is a free data retrieval call binding the contract method 0x8d62d949.
  3228  //
  3229  // Solidity: function wton() constant returns(address)
  3230  func (_DepositManagerI *DepositManagerICallerSession) Wton() (common.Address, error) {
  3231  	return _DepositManagerI.Contract.Wton(&_DepositManagerI.CallOpts)
  3232  }
  3233  
  3234  // Deposit is a paid mutator transaction binding the contract method 0x47e7ef24.
  3235  //
  3236  // Solidity: function deposit(address rootchain, uint256 amount) returns(bool)
  3237  func (_DepositManagerI *DepositManagerITransactor) Deposit(opts *bind.TransactOpts, rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
  3238  	return _DepositManagerI.contract.Transact(opts, "deposit", rootchain, amount)
  3239  }
  3240  
  3241  // Deposit is a paid mutator transaction binding the contract method 0x47e7ef24.
  3242  //
  3243  // Solidity: function deposit(address rootchain, uint256 amount) returns(bool)
  3244  func (_DepositManagerI *DepositManagerISession) Deposit(rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
  3245  	return _DepositManagerI.Contract.Deposit(&_DepositManagerI.TransactOpts, rootchain, amount)
  3246  }
  3247  
  3248  // Deposit is a paid mutator transaction binding the contract method 0x47e7ef24.
  3249  //
  3250  // Solidity: function deposit(address rootchain, uint256 amount) returns(bool)
  3251  func (_DepositManagerI *DepositManagerITransactorSession) Deposit(rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
  3252  	return _DepositManagerI.Contract.Deposit(&_DepositManagerI.TransactOpts, rootchain, amount)
  3253  }
  3254  
  3255  // ProcessRequest is a paid mutator transaction binding the contract method 0x5d6f7cca.
  3256  //
  3257  // Solidity: function processRequest(address rootchain) returns(bool)
  3258  func (_DepositManagerI *DepositManagerITransactor) ProcessRequest(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) {
  3259  	return _DepositManagerI.contract.Transact(opts, "processRequest", rootchain)
  3260  }
  3261  
  3262  // ProcessRequest is a paid mutator transaction binding the contract method 0x5d6f7cca.
  3263  //
  3264  // Solidity: function processRequest(address rootchain) returns(bool)
  3265  func (_DepositManagerI *DepositManagerISession) ProcessRequest(rootchain common.Address) (*types.Transaction, error) {
  3266  	return _DepositManagerI.Contract.ProcessRequest(&_DepositManagerI.TransactOpts, rootchain)
  3267  }
  3268  
  3269  // ProcessRequest is a paid mutator transaction binding the contract method 0x5d6f7cca.
  3270  //
  3271  // Solidity: function processRequest(address rootchain) returns(bool)
  3272  func (_DepositManagerI *DepositManagerITransactorSession) ProcessRequest(rootchain common.Address) (*types.Transaction, error) {
  3273  	return _DepositManagerI.Contract.ProcessRequest(&_DepositManagerI.TransactOpts, rootchain)
  3274  }
  3275  
  3276  // ProcessRequests is a paid mutator transaction binding the contract method 0x06260ceb.
  3277  //
  3278  // Solidity: function processRequests(address rootchain, uint256 n) returns(bool)
  3279  func (_DepositManagerI *DepositManagerITransactor) ProcessRequests(opts *bind.TransactOpts, rootchain common.Address, n *big.Int) (*types.Transaction, error) {
  3280  	return _DepositManagerI.contract.Transact(opts, "processRequests", rootchain, n)
  3281  }
  3282  
  3283  // ProcessRequests is a paid mutator transaction binding the contract method 0x06260ceb.
  3284  //
  3285  // Solidity: function processRequests(address rootchain, uint256 n) returns(bool)
  3286  func (_DepositManagerI *DepositManagerISession) ProcessRequests(rootchain common.Address, n *big.Int) (*types.Transaction, error) {
  3287  	return _DepositManagerI.Contract.ProcessRequests(&_DepositManagerI.TransactOpts, rootchain, n)
  3288  }
  3289  
  3290  // ProcessRequests is a paid mutator transaction binding the contract method 0x06260ceb.
  3291  //
  3292  // Solidity: function processRequests(address rootchain, uint256 n) returns(bool)
  3293  func (_DepositManagerI *DepositManagerITransactorSession) ProcessRequests(rootchain common.Address, n *big.Int) (*types.Transaction, error) {
  3294  	return _DepositManagerI.Contract.ProcessRequests(&_DepositManagerI.TransactOpts, rootchain, n)
  3295  }
  3296  
  3297  // RequestWithdrawal is a paid mutator transaction binding the contract method 0xda95ebf7.
  3298  //
  3299  // Solidity: function requestWithdrawal(address rootchain, uint256 amount) returns(bool)
  3300  func (_DepositManagerI *DepositManagerITransactor) RequestWithdrawal(opts *bind.TransactOpts, rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
  3301  	return _DepositManagerI.contract.Transact(opts, "requestWithdrawal", rootchain, amount)
  3302  }
  3303  
  3304  // RequestWithdrawal is a paid mutator transaction binding the contract method 0xda95ebf7.
  3305  //
  3306  // Solidity: function requestWithdrawal(address rootchain, uint256 amount) returns(bool)
  3307  func (_DepositManagerI *DepositManagerISession) RequestWithdrawal(rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
  3308  	return _DepositManagerI.Contract.RequestWithdrawal(&_DepositManagerI.TransactOpts, rootchain, amount)
  3309  }
  3310  
  3311  // RequestWithdrawal is a paid mutator transaction binding the contract method 0xda95ebf7.
  3312  //
  3313  // Solidity: function requestWithdrawal(address rootchain, uint256 amount) returns(bool)
  3314  func (_DepositManagerI *DepositManagerITransactorSession) RequestWithdrawal(rootchain common.Address, amount *big.Int) (*types.Transaction, error) {
  3315  	return _DepositManagerI.Contract.RequestWithdrawal(&_DepositManagerI.TransactOpts, rootchain, amount)
  3316  }
  3317  
  3318  // RequestWithdrawalAll is a paid mutator transaction binding the contract method 0x6b2160b7.
  3319  //
  3320  // Solidity: function requestWithdrawalAll(address rootchain) returns(bool)
  3321  func (_DepositManagerI *DepositManagerITransactor) RequestWithdrawalAll(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) {
  3322  	return _DepositManagerI.contract.Transact(opts, "requestWithdrawalAll", rootchain)
  3323  }
  3324  
  3325  // RequestWithdrawalAll is a paid mutator transaction binding the contract method 0x6b2160b7.
  3326  //
  3327  // Solidity: function requestWithdrawalAll(address rootchain) returns(bool)
  3328  func (_DepositManagerI *DepositManagerISession) RequestWithdrawalAll(rootchain common.Address) (*types.Transaction, error) {
  3329  	return _DepositManagerI.Contract.RequestWithdrawalAll(&_DepositManagerI.TransactOpts, rootchain)
  3330  }
  3331  
  3332  // RequestWithdrawalAll is a paid mutator transaction binding the contract method 0x6b2160b7.
  3333  //
  3334  // Solidity: function requestWithdrawalAll(address rootchain) returns(bool)
  3335  func (_DepositManagerI *DepositManagerITransactorSession) RequestWithdrawalAll(rootchain common.Address) (*types.Transaction, error) {
  3336  	return _DepositManagerI.Contract.RequestWithdrawalAll(&_DepositManagerI.TransactOpts, rootchain)
  3337  }
  3338  
  3339  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
  3340  //
  3341  // Solidity: function setSeigManager(address seigManager) returns()
  3342  func (_DepositManagerI *DepositManagerITransactor) SetSeigManager(opts *bind.TransactOpts, seigManager common.Address) (*types.Transaction, error) {
  3343  	return _DepositManagerI.contract.Transact(opts, "setSeigManager", seigManager)
  3344  }
  3345  
  3346  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
  3347  //
  3348  // Solidity: function setSeigManager(address seigManager) returns()
  3349  func (_DepositManagerI *DepositManagerISession) SetSeigManager(seigManager common.Address) (*types.Transaction, error) {
  3350  	return _DepositManagerI.Contract.SetSeigManager(&_DepositManagerI.TransactOpts, seigManager)
  3351  }
  3352  
  3353  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
  3354  //
  3355  // Solidity: function setSeigManager(address seigManager) returns()
  3356  func (_DepositManagerI *DepositManagerITransactorSession) SetSeigManager(seigManager common.Address) (*types.Transaction, error) {
  3357  	return _DepositManagerI.Contract.SetSeigManager(&_DepositManagerI.TransactOpts, seigManager)
  3358  }
  3359  
  3360  // ERC165ABI is the input ABI used to generate the binding from.
  3361  const ERC165ABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"
  3362  
  3363  // ERC165FuncSigs maps the 4-byte function signature to its string representation.
  3364  var ERC165FuncSigs = map[string]string{
  3365  	"01ffc9a7": "supportsInterface(bytes4)",
  3366  }
  3367  
  3368  // ERC165 is an auto generated Go binding around an Ethereum contract.
  3369  type ERC165 struct {
  3370  	ERC165Caller     // Read-only binding to the contract
  3371  	ERC165Transactor // Write-only binding to the contract
  3372  	ERC165Filterer   // Log filterer for contract events
  3373  }
  3374  
  3375  // ERC165Caller is an auto generated read-only Go binding around an Ethereum contract.
  3376  type ERC165Caller struct {
  3377  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  3378  }
  3379  
  3380  // ERC165Transactor is an auto generated write-only Go binding around an Ethereum contract.
  3381  type ERC165Transactor struct {
  3382  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  3383  }
  3384  
  3385  // ERC165Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
  3386  type ERC165Filterer struct {
  3387  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  3388  }
  3389  
  3390  // ERC165Session is an auto generated Go binding around an Ethereum contract,
  3391  // with pre-set call and transact options.
  3392  type ERC165Session struct {
  3393  	Contract     *ERC165           // Generic contract binding to set the session for
  3394  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  3395  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  3396  }
  3397  
  3398  // ERC165CallerSession is an auto generated read-only Go binding around an Ethereum contract,
  3399  // with pre-set call options.
  3400  type ERC165CallerSession struct {
  3401  	Contract *ERC165Caller // Generic contract caller binding to set the session for
  3402  	CallOpts bind.CallOpts // Call options to use throughout this session
  3403  }
  3404  
  3405  // ERC165TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  3406  // with pre-set transact options.
  3407  type ERC165TransactorSession struct {
  3408  	Contract     *ERC165Transactor // Generic contract transactor binding to set the session for
  3409  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  3410  }
  3411  
  3412  // ERC165Raw is an auto generated low-level Go binding around an Ethereum contract.
  3413  type ERC165Raw struct {
  3414  	Contract *ERC165 // Generic contract binding to access the raw methods on
  3415  }
  3416  
  3417  // ERC165CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  3418  type ERC165CallerRaw struct {
  3419  	Contract *ERC165Caller // Generic read-only contract binding to access the raw methods on
  3420  }
  3421  
  3422  // ERC165TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  3423  type ERC165TransactorRaw struct {
  3424  	Contract *ERC165Transactor // Generic write-only contract binding to access the raw methods on
  3425  }
  3426  
  3427  // NewERC165 creates a new instance of ERC165, bound to a specific deployed contract.
  3428  func NewERC165(address common.Address, backend bind.ContractBackend) (*ERC165, error) {
  3429  	contract, err := bindERC165(address, backend, backend, backend)
  3430  	if err != nil {
  3431  		return nil, err
  3432  	}
  3433  	return &ERC165{ERC165Caller: ERC165Caller{contract: contract}, ERC165Transactor: ERC165Transactor{contract: contract}, ERC165Filterer: ERC165Filterer{contract: contract}}, nil
  3434  }
  3435  
  3436  // NewERC165Caller creates a new read-only instance of ERC165, bound to a specific deployed contract.
  3437  func NewERC165Caller(address common.Address, caller bind.ContractCaller) (*ERC165Caller, error) {
  3438  	contract, err := bindERC165(address, caller, nil, nil)
  3439  	if err != nil {
  3440  		return nil, err
  3441  	}
  3442  	return &ERC165Caller{contract: contract}, nil
  3443  }
  3444  
  3445  // NewERC165Transactor creates a new write-only instance of ERC165, bound to a specific deployed contract.
  3446  func NewERC165Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC165Transactor, error) {
  3447  	contract, err := bindERC165(address, nil, transactor, nil)
  3448  	if err != nil {
  3449  		return nil, err
  3450  	}
  3451  	return &ERC165Transactor{contract: contract}, nil
  3452  }
  3453  
  3454  // NewERC165Filterer creates a new log filterer instance of ERC165, bound to a specific deployed contract.
  3455  func NewERC165Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC165Filterer, error) {
  3456  	contract, err := bindERC165(address, nil, nil, filterer)
  3457  	if err != nil {
  3458  		return nil, err
  3459  	}
  3460  	return &ERC165Filterer{contract: contract}, nil
  3461  }
  3462  
  3463  // bindERC165 binds a generic wrapper to an already deployed contract.
  3464  func bindERC165(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  3465  	parsed, err := abi.JSON(strings.NewReader(ERC165ABI))
  3466  	if err != nil {
  3467  		return nil, err
  3468  	}
  3469  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  3470  }
  3471  
  3472  // Call invokes the (constant) contract method with params as input values and
  3473  // sets the output to result. The result type might be a single field for simple
  3474  // returns, a slice of interfaces for anonymous returns and a struct for named
  3475  // returns.
  3476  func (_ERC165 *ERC165Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  3477  	return _ERC165.Contract.ERC165Caller.contract.Call(opts, result, method, params...)
  3478  }
  3479  
  3480  // Transfer initiates a plain transaction to move funds to the contract, calling
  3481  // its default method if one is available.
  3482  func (_ERC165 *ERC165Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  3483  	return _ERC165.Contract.ERC165Transactor.contract.Transfer(opts)
  3484  }
  3485  
  3486  // Transact invokes the (paid) contract method with params as input values.
  3487  func (_ERC165 *ERC165Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  3488  	return _ERC165.Contract.ERC165Transactor.contract.Transact(opts, method, params...)
  3489  }
  3490  
  3491  // Call invokes the (constant) contract method with params as input values and
  3492  // sets the output to result. The result type might be a single field for simple
  3493  // returns, a slice of interfaces for anonymous returns and a struct for named
  3494  // returns.
  3495  func (_ERC165 *ERC165CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  3496  	return _ERC165.Contract.contract.Call(opts, result, method, params...)
  3497  }
  3498  
  3499  // Transfer initiates a plain transaction to move funds to the contract, calling
  3500  // its default method if one is available.
  3501  func (_ERC165 *ERC165TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  3502  	return _ERC165.Contract.contract.Transfer(opts)
  3503  }
  3504  
  3505  // Transact invokes the (paid) contract method with params as input values.
  3506  func (_ERC165 *ERC165TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  3507  	return _ERC165.Contract.contract.Transact(opts, method, params...)
  3508  }
  3509  
  3510  // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
  3511  //
  3512  // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool)
  3513  func (_ERC165 *ERC165Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
  3514  	var (
  3515  		ret0 = new(bool)
  3516  	)
  3517  	out := ret0
  3518  	err := _ERC165.contract.Call(opts, out, "supportsInterface", interfaceId)
  3519  	return *ret0, err
  3520  }
  3521  
  3522  // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
  3523  //
  3524  // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool)
  3525  func (_ERC165 *ERC165Session) SupportsInterface(interfaceId [4]byte) (bool, error) {
  3526  	return _ERC165.Contract.SupportsInterface(&_ERC165.CallOpts, interfaceId)
  3527  }
  3528  
  3529  // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
  3530  //
  3531  // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool)
  3532  func (_ERC165 *ERC165CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
  3533  	return _ERC165.Contract.SupportsInterface(&_ERC165.CallOpts, interfaceId)
  3534  }
  3535  
  3536  // ERC165CheckerABI is the input ABI used to generate the binding from.
  3537  const ERC165CheckerABI = "[]"
  3538  
  3539  // ERC165CheckerBin is the compiled bytecode used for deploying new contracts.
  3540  var ERC165CheckerBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a72315820ea851d268567a3ed8f55b193eb1a6f3028b7565ea2152c791833f991fbaa44e864736f6c634300050c0032"
  3541  
  3542  // DeployERC165Checker deploys a new Ethereum contract, binding an instance of ERC165Checker to it.
  3543  func DeployERC165Checker(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC165Checker, error) {
  3544  	parsed, err := abi.JSON(strings.NewReader(ERC165CheckerABI))
  3545  	if err != nil {
  3546  		return common.Address{}, nil, nil, err
  3547  	}
  3548  
  3549  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC165CheckerBin), backend)
  3550  	if err != nil {
  3551  		return common.Address{}, nil, nil, err
  3552  	}
  3553  	return address, tx, &ERC165Checker{ERC165CheckerCaller: ERC165CheckerCaller{contract: contract}, ERC165CheckerTransactor: ERC165CheckerTransactor{contract: contract}, ERC165CheckerFilterer: ERC165CheckerFilterer{contract: contract}}, nil
  3554  }
  3555  
  3556  // ERC165Checker is an auto generated Go binding around an Ethereum contract.
  3557  type ERC165Checker struct {
  3558  	ERC165CheckerCaller     // Read-only binding to the contract
  3559  	ERC165CheckerTransactor // Write-only binding to the contract
  3560  	ERC165CheckerFilterer   // Log filterer for contract events
  3561  }
  3562  
  3563  // ERC165CheckerCaller is an auto generated read-only Go binding around an Ethereum contract.
  3564  type ERC165CheckerCaller struct {
  3565  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  3566  }
  3567  
  3568  // ERC165CheckerTransactor is an auto generated write-only Go binding around an Ethereum contract.
  3569  type ERC165CheckerTransactor struct {
  3570  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  3571  }
  3572  
  3573  // ERC165CheckerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  3574  type ERC165CheckerFilterer struct {
  3575  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  3576  }
  3577  
  3578  // ERC165CheckerSession is an auto generated Go binding around an Ethereum contract,
  3579  // with pre-set call and transact options.
  3580  type ERC165CheckerSession struct {
  3581  	Contract     *ERC165Checker    // Generic contract binding to set the session for
  3582  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  3583  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  3584  }
  3585  
  3586  // ERC165CheckerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  3587  // with pre-set call options.
  3588  type ERC165CheckerCallerSession struct {
  3589  	Contract *ERC165CheckerCaller // Generic contract caller binding to set the session for
  3590  	CallOpts bind.CallOpts        // Call options to use throughout this session
  3591  }
  3592  
  3593  // ERC165CheckerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  3594  // with pre-set transact options.
  3595  type ERC165CheckerTransactorSession struct {
  3596  	Contract     *ERC165CheckerTransactor // Generic contract transactor binding to set the session for
  3597  	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
  3598  }
  3599  
  3600  // ERC165CheckerRaw is an auto generated low-level Go binding around an Ethereum contract.
  3601  type ERC165CheckerRaw struct {
  3602  	Contract *ERC165Checker // Generic contract binding to access the raw methods on
  3603  }
  3604  
  3605  // ERC165CheckerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  3606  type ERC165CheckerCallerRaw struct {
  3607  	Contract *ERC165CheckerCaller // Generic read-only contract binding to access the raw methods on
  3608  }
  3609  
  3610  // ERC165CheckerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  3611  type ERC165CheckerTransactorRaw struct {
  3612  	Contract *ERC165CheckerTransactor // Generic write-only contract binding to access the raw methods on
  3613  }
  3614  
  3615  // NewERC165Checker creates a new instance of ERC165Checker, bound to a specific deployed contract.
  3616  func NewERC165Checker(address common.Address, backend bind.ContractBackend) (*ERC165Checker, error) {
  3617  	contract, err := bindERC165Checker(address, backend, backend, backend)
  3618  	if err != nil {
  3619  		return nil, err
  3620  	}
  3621  	return &ERC165Checker{ERC165CheckerCaller: ERC165CheckerCaller{contract: contract}, ERC165CheckerTransactor: ERC165CheckerTransactor{contract: contract}, ERC165CheckerFilterer: ERC165CheckerFilterer{contract: contract}}, nil
  3622  }
  3623  
  3624  // NewERC165CheckerCaller creates a new read-only instance of ERC165Checker, bound to a specific deployed contract.
  3625  func NewERC165CheckerCaller(address common.Address, caller bind.ContractCaller) (*ERC165CheckerCaller, error) {
  3626  	contract, err := bindERC165Checker(address, caller, nil, nil)
  3627  	if err != nil {
  3628  		return nil, err
  3629  	}
  3630  	return &ERC165CheckerCaller{contract: contract}, nil
  3631  }
  3632  
  3633  // NewERC165CheckerTransactor creates a new write-only instance of ERC165Checker, bound to a specific deployed contract.
  3634  func NewERC165CheckerTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC165CheckerTransactor, error) {
  3635  	contract, err := bindERC165Checker(address, nil, transactor, nil)
  3636  	if err != nil {
  3637  		return nil, err
  3638  	}
  3639  	return &ERC165CheckerTransactor{contract: contract}, nil
  3640  }
  3641  
  3642  // NewERC165CheckerFilterer creates a new log filterer instance of ERC165Checker, bound to a specific deployed contract.
  3643  func NewERC165CheckerFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC165CheckerFilterer, error) {
  3644  	contract, err := bindERC165Checker(address, nil, nil, filterer)
  3645  	if err != nil {
  3646  		return nil, err
  3647  	}
  3648  	return &ERC165CheckerFilterer{contract: contract}, nil
  3649  }
  3650  
  3651  // bindERC165Checker binds a generic wrapper to an already deployed contract.
  3652  func bindERC165Checker(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  3653  	parsed, err := abi.JSON(strings.NewReader(ERC165CheckerABI))
  3654  	if err != nil {
  3655  		return nil, err
  3656  	}
  3657  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  3658  }
  3659  
  3660  // Call invokes the (constant) contract method with params as input values and
  3661  // sets the output to result. The result type might be a single field for simple
  3662  // returns, a slice of interfaces for anonymous returns and a struct for named
  3663  // returns.
  3664  func (_ERC165Checker *ERC165CheckerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  3665  	return _ERC165Checker.Contract.ERC165CheckerCaller.contract.Call(opts, result, method, params...)
  3666  }
  3667  
  3668  // Transfer initiates a plain transaction to move funds to the contract, calling
  3669  // its default method if one is available.
  3670  func (_ERC165Checker *ERC165CheckerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  3671  	return _ERC165Checker.Contract.ERC165CheckerTransactor.contract.Transfer(opts)
  3672  }
  3673  
  3674  // Transact invokes the (paid) contract method with params as input values.
  3675  func (_ERC165Checker *ERC165CheckerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  3676  	return _ERC165Checker.Contract.ERC165CheckerTransactor.contract.Transact(opts, method, params...)
  3677  }
  3678  
  3679  // Call invokes the (constant) contract method with params as input values and
  3680  // sets the output to result. The result type might be a single field for simple
  3681  // returns, a slice of interfaces for anonymous returns and a struct for named
  3682  // returns.
  3683  func (_ERC165Checker *ERC165CheckerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  3684  	return _ERC165Checker.Contract.contract.Call(opts, result, method, params...)
  3685  }
  3686  
  3687  // Transfer initiates a plain transaction to move funds to the contract, calling
  3688  // its default method if one is available.
  3689  func (_ERC165Checker *ERC165CheckerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  3690  	return _ERC165Checker.Contract.contract.Transfer(opts)
  3691  }
  3692  
  3693  // Transact invokes the (paid) contract method with params as input values.
  3694  func (_ERC165Checker *ERC165CheckerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  3695  	return _ERC165Checker.Contract.contract.Transact(opts, method, params...)
  3696  }
  3697  
  3698  // ERC20ABI is the input ABI used to generate the binding from.
  3699  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\"}]"
  3700  
  3701  // ERC20FuncSigs maps the 4-byte function signature to its string representation.
  3702  var ERC20FuncSigs = map[string]string{
  3703  	"dd62ed3e": "allowance(address,address)",
  3704  	"095ea7b3": "approve(address,uint256)",
  3705  	"70a08231": "balanceOf(address)",
  3706  	"a457c2d7": "decreaseAllowance(address,uint256)",
  3707  	"39509351": "increaseAllowance(address,uint256)",
  3708  	"18160ddd": "totalSupply()",
  3709  	"a9059cbb": "transfer(address,uint256)",
  3710  	"23b872dd": "transferFrom(address,address,uint256)",
  3711  }
  3712  
  3713  // ERC20Bin is the compiled bytecode used for deploying new contracts.
  3714  var ERC20Bin = "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"
  3715  
  3716  // DeployERC20 deploys a new Ethereum contract, binding an instance of ERC20 to it.
  3717  func DeployERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20, error) {
  3718  	parsed, err := abi.JSON(strings.NewReader(ERC20ABI))
  3719  	if err != nil {
  3720  		return common.Address{}, nil, nil, err
  3721  	}
  3722  
  3723  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20Bin), backend)
  3724  	if err != nil {
  3725  		return common.Address{}, nil, nil, err
  3726  	}
  3727  	return address, tx, &ERC20{ERC20Caller: ERC20Caller{contract: contract}, ERC20Transactor: ERC20Transactor{contract: contract}, ERC20Filterer: ERC20Filterer{contract: contract}}, nil
  3728  }
  3729  
  3730  // ERC20 is an auto generated Go binding around an Ethereum contract.
  3731  type ERC20 struct {
  3732  	ERC20Caller     // Read-only binding to the contract
  3733  	ERC20Transactor // Write-only binding to the contract
  3734  	ERC20Filterer   // Log filterer for contract events
  3735  }
  3736  
  3737  // ERC20Caller is an auto generated read-only Go binding around an Ethereum contract.
  3738  type ERC20Caller struct {
  3739  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  3740  }
  3741  
  3742  // ERC20Transactor is an auto generated write-only Go binding around an Ethereum contract.
  3743  type ERC20Transactor struct {
  3744  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  3745  }
  3746  
  3747  // ERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
  3748  type ERC20Filterer struct {
  3749  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  3750  }
  3751  
  3752  // ERC20Session is an auto generated Go binding around an Ethereum contract,
  3753  // with pre-set call and transact options.
  3754  type ERC20Session struct {
  3755  	Contract     *ERC20            // Generic contract binding to set the session for
  3756  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  3757  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  3758  }
  3759  
  3760  // ERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract,
  3761  // with pre-set call options.
  3762  type ERC20CallerSession struct {
  3763  	Contract *ERC20Caller  // Generic contract caller binding to set the session for
  3764  	CallOpts bind.CallOpts // Call options to use throughout this session
  3765  }
  3766  
  3767  // ERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  3768  // with pre-set transact options.
  3769  type ERC20TransactorSession struct {
  3770  	Contract     *ERC20Transactor  // Generic contract transactor binding to set the session for
  3771  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  3772  }
  3773  
  3774  // ERC20Raw is an auto generated low-level Go binding around an Ethereum contract.
  3775  type ERC20Raw struct {
  3776  	Contract *ERC20 // Generic contract binding to access the raw methods on
  3777  }
  3778  
  3779  // ERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  3780  type ERC20CallerRaw struct {
  3781  	Contract *ERC20Caller // Generic read-only contract binding to access the raw methods on
  3782  }
  3783  
  3784  // ERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  3785  type ERC20TransactorRaw struct {
  3786  	Contract *ERC20Transactor // Generic write-only contract binding to access the raw methods on
  3787  }
  3788  
  3789  // NewERC20 creates a new instance of ERC20, bound to a specific deployed contract.
  3790  func NewERC20(address common.Address, backend bind.ContractBackend) (*ERC20, error) {
  3791  	contract, err := bindERC20(address, backend, backend, backend)
  3792  	if err != nil {
  3793  		return nil, err
  3794  	}
  3795  	return &ERC20{ERC20Caller: ERC20Caller{contract: contract}, ERC20Transactor: ERC20Transactor{contract: contract}, ERC20Filterer: ERC20Filterer{contract: contract}}, nil
  3796  }
  3797  
  3798  // NewERC20Caller creates a new read-only instance of ERC20, bound to a specific deployed contract.
  3799  func NewERC20Caller(address common.Address, caller bind.ContractCaller) (*ERC20Caller, error) {
  3800  	contract, err := bindERC20(address, caller, nil, nil)
  3801  	if err != nil {
  3802  		return nil, err
  3803  	}
  3804  	return &ERC20Caller{contract: contract}, nil
  3805  }
  3806  
  3807  // NewERC20Transactor creates a new write-only instance of ERC20, bound to a specific deployed contract.
  3808  func NewERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC20Transactor, error) {
  3809  	contract, err := bindERC20(address, nil, transactor, nil)
  3810  	if err != nil {
  3811  		return nil, err
  3812  	}
  3813  	return &ERC20Transactor{contract: contract}, nil
  3814  }
  3815  
  3816  // NewERC20Filterer creates a new log filterer instance of ERC20, bound to a specific deployed contract.
  3817  func NewERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC20Filterer, error) {
  3818  	contract, err := bindERC20(address, nil, nil, filterer)
  3819  	if err != nil {
  3820  		return nil, err
  3821  	}
  3822  	return &ERC20Filterer{contract: contract}, nil
  3823  }
  3824  
  3825  // bindERC20 binds a generic wrapper to an already deployed contract.
  3826  func bindERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  3827  	parsed, err := abi.JSON(strings.NewReader(ERC20ABI))
  3828  	if err != nil {
  3829  		return nil, err
  3830  	}
  3831  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  3832  }
  3833  
  3834  // Call invokes the (constant) contract method with params as input values and
  3835  // sets the output to result. The result type might be a single field for simple
  3836  // returns, a slice of interfaces for anonymous returns and a struct for named
  3837  // returns.
  3838  func (_ERC20 *ERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  3839  	return _ERC20.Contract.ERC20Caller.contract.Call(opts, result, method, params...)
  3840  }
  3841  
  3842  // Transfer initiates a plain transaction to move funds to the contract, calling
  3843  // its default method if one is available.
  3844  func (_ERC20 *ERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  3845  	return _ERC20.Contract.ERC20Transactor.contract.Transfer(opts)
  3846  }
  3847  
  3848  // Transact invokes the (paid) contract method with params as input values.
  3849  func (_ERC20 *ERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  3850  	return _ERC20.Contract.ERC20Transactor.contract.Transact(opts, method, params...)
  3851  }
  3852  
  3853  // Call invokes the (constant) contract method with params as input values and
  3854  // sets the output to result. The result type might be a single field for simple
  3855  // returns, a slice of interfaces for anonymous returns and a struct for named
  3856  // returns.
  3857  func (_ERC20 *ERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  3858  	return _ERC20.Contract.contract.Call(opts, result, method, params...)
  3859  }
  3860  
  3861  // Transfer initiates a plain transaction to move funds to the contract, calling
  3862  // its default method if one is available.
  3863  func (_ERC20 *ERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  3864  	return _ERC20.Contract.contract.Transfer(opts)
  3865  }
  3866  
  3867  // Transact invokes the (paid) contract method with params as input values.
  3868  func (_ERC20 *ERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  3869  	return _ERC20.Contract.contract.Transact(opts, method, params...)
  3870  }
  3871  
  3872  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  3873  //
  3874  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  3875  func (_ERC20 *ERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
  3876  	var (
  3877  		ret0 = new(*big.Int)
  3878  	)
  3879  	out := ret0
  3880  	err := _ERC20.contract.Call(opts, out, "allowance", owner, spender)
  3881  	return *ret0, err
  3882  }
  3883  
  3884  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  3885  //
  3886  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  3887  func (_ERC20 *ERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  3888  	return _ERC20.Contract.Allowance(&_ERC20.CallOpts, owner, spender)
  3889  }
  3890  
  3891  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  3892  //
  3893  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  3894  func (_ERC20 *ERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  3895  	return _ERC20.Contract.Allowance(&_ERC20.CallOpts, owner, spender)
  3896  }
  3897  
  3898  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  3899  //
  3900  // Solidity: function balanceOf(address account) constant returns(uint256)
  3901  func (_ERC20 *ERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  3902  	var (
  3903  		ret0 = new(*big.Int)
  3904  	)
  3905  	out := ret0
  3906  	err := _ERC20.contract.Call(opts, out, "balanceOf", account)
  3907  	return *ret0, err
  3908  }
  3909  
  3910  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  3911  //
  3912  // Solidity: function balanceOf(address account) constant returns(uint256)
  3913  func (_ERC20 *ERC20Session) BalanceOf(account common.Address) (*big.Int, error) {
  3914  	return _ERC20.Contract.BalanceOf(&_ERC20.CallOpts, account)
  3915  }
  3916  
  3917  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  3918  //
  3919  // Solidity: function balanceOf(address account) constant returns(uint256)
  3920  func (_ERC20 *ERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) {
  3921  	return _ERC20.Contract.BalanceOf(&_ERC20.CallOpts, account)
  3922  }
  3923  
  3924  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  3925  //
  3926  // Solidity: function totalSupply() constant returns(uint256)
  3927  func (_ERC20 *ERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
  3928  	var (
  3929  		ret0 = new(*big.Int)
  3930  	)
  3931  	out := ret0
  3932  	err := _ERC20.contract.Call(opts, out, "totalSupply")
  3933  	return *ret0, err
  3934  }
  3935  
  3936  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  3937  //
  3938  // Solidity: function totalSupply() constant returns(uint256)
  3939  func (_ERC20 *ERC20Session) TotalSupply() (*big.Int, error) {
  3940  	return _ERC20.Contract.TotalSupply(&_ERC20.CallOpts)
  3941  }
  3942  
  3943  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  3944  //
  3945  // Solidity: function totalSupply() constant returns(uint256)
  3946  func (_ERC20 *ERC20CallerSession) TotalSupply() (*big.Int, error) {
  3947  	return _ERC20.Contract.TotalSupply(&_ERC20.CallOpts)
  3948  }
  3949  
  3950  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  3951  //
  3952  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  3953  func (_ERC20 *ERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
  3954  	return _ERC20.contract.Transact(opts, "approve", spender, amount)
  3955  }
  3956  
  3957  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  3958  //
  3959  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  3960  func (_ERC20 *ERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  3961  	return _ERC20.Contract.Approve(&_ERC20.TransactOpts, spender, amount)
  3962  }
  3963  
  3964  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  3965  //
  3966  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  3967  func (_ERC20 *ERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  3968  	return _ERC20.Contract.Approve(&_ERC20.TransactOpts, spender, amount)
  3969  }
  3970  
  3971  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  3972  //
  3973  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  3974  func (_ERC20 *ERC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  3975  	return _ERC20.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
  3976  }
  3977  
  3978  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  3979  //
  3980  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  3981  func (_ERC20 *ERC20Session) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  3982  	return _ERC20.Contract.DecreaseAllowance(&_ERC20.TransactOpts, spender, subtractedValue)
  3983  }
  3984  
  3985  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  3986  //
  3987  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  3988  func (_ERC20 *ERC20TransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  3989  	return _ERC20.Contract.DecreaseAllowance(&_ERC20.TransactOpts, spender, subtractedValue)
  3990  }
  3991  
  3992  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  3993  //
  3994  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  3995  func (_ERC20 *ERC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  3996  	return _ERC20.contract.Transact(opts, "increaseAllowance", spender, addedValue)
  3997  }
  3998  
  3999  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  4000  //
  4001  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  4002  func (_ERC20 *ERC20Session) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  4003  	return _ERC20.Contract.IncreaseAllowance(&_ERC20.TransactOpts, spender, addedValue)
  4004  }
  4005  
  4006  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  4007  //
  4008  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  4009  func (_ERC20 *ERC20TransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  4010  	return _ERC20.Contract.IncreaseAllowance(&_ERC20.TransactOpts, spender, addedValue)
  4011  }
  4012  
  4013  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  4014  //
  4015  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  4016  func (_ERC20 *ERC20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4017  	return _ERC20.contract.Transact(opts, "transfer", recipient, amount)
  4018  }
  4019  
  4020  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  4021  //
  4022  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  4023  func (_ERC20 *ERC20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4024  	return _ERC20.Contract.Transfer(&_ERC20.TransactOpts, recipient, amount)
  4025  }
  4026  
  4027  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  4028  //
  4029  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  4030  func (_ERC20 *ERC20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4031  	return _ERC20.Contract.Transfer(&_ERC20.TransactOpts, recipient, amount)
  4032  }
  4033  
  4034  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  4035  //
  4036  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  4037  func (_ERC20 *ERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4038  	return _ERC20.contract.Transact(opts, "transferFrom", sender, recipient, amount)
  4039  }
  4040  
  4041  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  4042  //
  4043  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  4044  func (_ERC20 *ERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4045  	return _ERC20.Contract.TransferFrom(&_ERC20.TransactOpts, sender, recipient, amount)
  4046  }
  4047  
  4048  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  4049  //
  4050  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  4051  func (_ERC20 *ERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4052  	return _ERC20.Contract.TransferFrom(&_ERC20.TransactOpts, sender, recipient, amount)
  4053  }
  4054  
  4055  // 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.
  4056  type ERC20ApprovalIterator struct {
  4057  	Event *ERC20Approval // Event containing the contract specifics and raw log
  4058  
  4059  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  4060  	event    string              // Event name to use for unpacking event data
  4061  
  4062  	logs chan types.Log        // Log channel receiving the found contract events
  4063  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  4064  	done bool                  // Whether the subscription completed delivering logs
  4065  	fail error                 // Occurred error to stop iteration
  4066  }
  4067  
  4068  // Next advances the iterator to the subsequent event, returning whether there
  4069  // are any more events found. In case of a retrieval or parsing error, false is
  4070  // returned and Error() can be queried for the exact failure.
  4071  func (it *ERC20ApprovalIterator) Next() bool {
  4072  	// If the iterator failed, stop iterating
  4073  	if it.fail != nil {
  4074  		return false
  4075  	}
  4076  	// If the iterator completed, deliver directly whatever's available
  4077  	if it.done {
  4078  		select {
  4079  		case log := <-it.logs:
  4080  			it.Event = new(ERC20Approval)
  4081  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4082  				it.fail = err
  4083  				return false
  4084  			}
  4085  			it.Event.Raw = log
  4086  			return true
  4087  
  4088  		default:
  4089  			return false
  4090  		}
  4091  	}
  4092  	// Iterator still in progress, wait for either a data or an error event
  4093  	select {
  4094  	case log := <-it.logs:
  4095  		it.Event = new(ERC20Approval)
  4096  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4097  			it.fail = err
  4098  			return false
  4099  		}
  4100  		it.Event.Raw = log
  4101  		return true
  4102  
  4103  	case err := <-it.sub.Err():
  4104  		it.done = true
  4105  		it.fail = err
  4106  		return it.Next()
  4107  	}
  4108  }
  4109  
  4110  // Error returns any retrieval or parsing error occurred during filtering.
  4111  func (it *ERC20ApprovalIterator) Error() error {
  4112  	return it.fail
  4113  }
  4114  
  4115  // Close terminates the iteration process, releasing any pending underlying
  4116  // resources.
  4117  func (it *ERC20ApprovalIterator) Close() error {
  4118  	it.sub.Unsubscribe()
  4119  	return nil
  4120  }
  4121  
  4122  // ERC20Approval represents a Approval event raised by the ERC20 contract.
  4123  type ERC20Approval struct {
  4124  	Owner   common.Address
  4125  	Spender common.Address
  4126  	Value   *big.Int
  4127  	Raw     types.Log // Blockchain specific contextual infos
  4128  }
  4129  
  4130  // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  4131  //
  4132  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  4133  func (_ERC20 *ERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20ApprovalIterator, error) {
  4134  
  4135  	var ownerRule []interface{}
  4136  	for _, ownerItem := range owner {
  4137  		ownerRule = append(ownerRule, ownerItem)
  4138  	}
  4139  	var spenderRule []interface{}
  4140  	for _, spenderItem := range spender {
  4141  		spenderRule = append(spenderRule, spenderItem)
  4142  	}
  4143  
  4144  	logs, sub, err := _ERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
  4145  	if err != nil {
  4146  		return nil, err
  4147  	}
  4148  	return &ERC20ApprovalIterator{contract: _ERC20.contract, event: "Approval", logs: logs, sub: sub}, nil
  4149  }
  4150  
  4151  // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  4152  //
  4153  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  4154  func (_ERC20 *ERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
  4155  
  4156  	var ownerRule []interface{}
  4157  	for _, ownerItem := range owner {
  4158  		ownerRule = append(ownerRule, ownerItem)
  4159  	}
  4160  	var spenderRule []interface{}
  4161  	for _, spenderItem := range spender {
  4162  		spenderRule = append(spenderRule, spenderItem)
  4163  	}
  4164  
  4165  	logs, sub, err := _ERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
  4166  	if err != nil {
  4167  		return nil, err
  4168  	}
  4169  	return event.NewSubscription(func(quit <-chan struct{}) error {
  4170  		defer sub.Unsubscribe()
  4171  		for {
  4172  			select {
  4173  			case log := <-logs:
  4174  				// New log arrived, parse the event and forward to the user
  4175  				event := new(ERC20Approval)
  4176  				if err := _ERC20.contract.UnpackLog(event, "Approval", log); err != nil {
  4177  					return err
  4178  				}
  4179  				event.Raw = log
  4180  
  4181  				select {
  4182  				case sink <- event:
  4183  				case err := <-sub.Err():
  4184  					return err
  4185  				case <-quit:
  4186  					return nil
  4187  				}
  4188  			case err := <-sub.Err():
  4189  				return err
  4190  			case <-quit:
  4191  				return nil
  4192  			}
  4193  		}
  4194  	}), nil
  4195  }
  4196  
  4197  // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  4198  //
  4199  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  4200  func (_ERC20 *ERC20Filterer) ParseApproval(log types.Log) (*ERC20Approval, error) {
  4201  	event := new(ERC20Approval)
  4202  	if err := _ERC20.contract.UnpackLog(event, "Approval", log); err != nil {
  4203  		return nil, err
  4204  	}
  4205  	return event, nil
  4206  }
  4207  
  4208  // 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.
  4209  type ERC20TransferIterator struct {
  4210  	Event *ERC20Transfer // Event containing the contract specifics and raw log
  4211  
  4212  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  4213  	event    string              // Event name to use for unpacking event data
  4214  
  4215  	logs chan types.Log        // Log channel receiving the found contract events
  4216  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  4217  	done bool                  // Whether the subscription completed delivering logs
  4218  	fail error                 // Occurred error to stop iteration
  4219  }
  4220  
  4221  // Next advances the iterator to the subsequent event, returning whether there
  4222  // are any more events found. In case of a retrieval or parsing error, false is
  4223  // returned and Error() can be queried for the exact failure.
  4224  func (it *ERC20TransferIterator) Next() bool {
  4225  	// If the iterator failed, stop iterating
  4226  	if it.fail != nil {
  4227  		return false
  4228  	}
  4229  	// If the iterator completed, deliver directly whatever's available
  4230  	if it.done {
  4231  		select {
  4232  		case log := <-it.logs:
  4233  			it.Event = new(ERC20Transfer)
  4234  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4235  				it.fail = err
  4236  				return false
  4237  			}
  4238  			it.Event.Raw = log
  4239  			return true
  4240  
  4241  		default:
  4242  			return false
  4243  		}
  4244  	}
  4245  	// Iterator still in progress, wait for either a data or an error event
  4246  	select {
  4247  	case log := <-it.logs:
  4248  		it.Event = new(ERC20Transfer)
  4249  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4250  			it.fail = err
  4251  			return false
  4252  		}
  4253  		it.Event.Raw = log
  4254  		return true
  4255  
  4256  	case err := <-it.sub.Err():
  4257  		it.done = true
  4258  		it.fail = err
  4259  		return it.Next()
  4260  	}
  4261  }
  4262  
  4263  // Error returns any retrieval or parsing error occurred during filtering.
  4264  func (it *ERC20TransferIterator) Error() error {
  4265  	return it.fail
  4266  }
  4267  
  4268  // Close terminates the iteration process, releasing any pending underlying
  4269  // resources.
  4270  func (it *ERC20TransferIterator) Close() error {
  4271  	it.sub.Unsubscribe()
  4272  	return nil
  4273  }
  4274  
  4275  // ERC20Transfer represents a Transfer event raised by the ERC20 contract.
  4276  type ERC20Transfer struct {
  4277  	From  common.Address
  4278  	To    common.Address
  4279  	Value *big.Int
  4280  	Raw   types.Log // Blockchain specific contextual infos
  4281  }
  4282  
  4283  // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  4284  //
  4285  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  4286  func (_ERC20 *ERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20TransferIterator, error) {
  4287  
  4288  	var fromRule []interface{}
  4289  	for _, fromItem := range from {
  4290  		fromRule = append(fromRule, fromItem)
  4291  	}
  4292  	var toRule []interface{}
  4293  	for _, toItem := range to {
  4294  		toRule = append(toRule, toItem)
  4295  	}
  4296  
  4297  	logs, sub, err := _ERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
  4298  	if err != nil {
  4299  		return nil, err
  4300  	}
  4301  	return &ERC20TransferIterator{contract: _ERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil
  4302  }
  4303  
  4304  // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  4305  //
  4306  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  4307  func (_ERC20 *ERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) {
  4308  
  4309  	var fromRule []interface{}
  4310  	for _, fromItem := range from {
  4311  		fromRule = append(fromRule, fromItem)
  4312  	}
  4313  	var toRule []interface{}
  4314  	for _, toItem := range to {
  4315  		toRule = append(toRule, toItem)
  4316  	}
  4317  
  4318  	logs, sub, err := _ERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
  4319  	if err != nil {
  4320  		return nil, err
  4321  	}
  4322  	return event.NewSubscription(func(quit <-chan struct{}) error {
  4323  		defer sub.Unsubscribe()
  4324  		for {
  4325  			select {
  4326  			case log := <-logs:
  4327  				// New log arrived, parse the event and forward to the user
  4328  				event := new(ERC20Transfer)
  4329  				if err := _ERC20.contract.UnpackLog(event, "Transfer", log); err != nil {
  4330  					return err
  4331  				}
  4332  				event.Raw = log
  4333  
  4334  				select {
  4335  				case sink <- event:
  4336  				case err := <-sub.Err():
  4337  					return err
  4338  				case <-quit:
  4339  					return nil
  4340  				}
  4341  			case err := <-sub.Err():
  4342  				return err
  4343  			case <-quit:
  4344  				return nil
  4345  			}
  4346  		}
  4347  	}), nil
  4348  }
  4349  
  4350  // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  4351  //
  4352  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  4353  func (_ERC20 *ERC20Filterer) ParseTransfer(log types.Log) (*ERC20Transfer, error) {
  4354  	event := new(ERC20Transfer)
  4355  	if err := _ERC20.contract.UnpackLog(event, "Transfer", log); err != nil {
  4356  		return nil, err
  4357  	}
  4358  	return event, nil
  4359  }
  4360  
  4361  // ERC20BurnableABI is the input ABI used to generate the binding from.
  4362  const ERC20BurnableABI = "[{\"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\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burnFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"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\"}]"
  4363  
  4364  // ERC20BurnableFuncSigs maps the 4-byte function signature to its string representation.
  4365  var ERC20BurnableFuncSigs = map[string]string{
  4366  	"dd62ed3e": "allowance(address,address)",
  4367  	"095ea7b3": "approve(address,uint256)",
  4368  	"70a08231": "balanceOf(address)",
  4369  	"42966c68": "burn(uint256)",
  4370  	"79cc6790": "burnFrom(address,uint256)",
  4371  	"a457c2d7": "decreaseAllowance(address,uint256)",
  4372  	"39509351": "increaseAllowance(address,uint256)",
  4373  	"18160ddd": "totalSupply()",
  4374  	"a9059cbb": "transfer(address,uint256)",
  4375  	"23b872dd": "transferFrom(address,address,uint256)",
  4376  }
  4377  
  4378  // ERC20BurnableBin is the compiled bytecode used for deploying new contracts.
  4379  var ERC20BurnableBin = "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"
  4380  
  4381  // DeployERC20Burnable deploys a new Ethereum contract, binding an instance of ERC20Burnable to it.
  4382  func DeployERC20Burnable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20Burnable, error) {
  4383  	parsed, err := abi.JSON(strings.NewReader(ERC20BurnableABI))
  4384  	if err != nil {
  4385  		return common.Address{}, nil, nil, err
  4386  	}
  4387  
  4388  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20BurnableBin), backend)
  4389  	if err != nil {
  4390  		return common.Address{}, nil, nil, err
  4391  	}
  4392  	return address, tx, &ERC20Burnable{ERC20BurnableCaller: ERC20BurnableCaller{contract: contract}, ERC20BurnableTransactor: ERC20BurnableTransactor{contract: contract}, ERC20BurnableFilterer: ERC20BurnableFilterer{contract: contract}}, nil
  4393  }
  4394  
  4395  // ERC20Burnable is an auto generated Go binding around an Ethereum contract.
  4396  type ERC20Burnable struct {
  4397  	ERC20BurnableCaller     // Read-only binding to the contract
  4398  	ERC20BurnableTransactor // Write-only binding to the contract
  4399  	ERC20BurnableFilterer   // Log filterer for contract events
  4400  }
  4401  
  4402  // ERC20BurnableCaller is an auto generated read-only Go binding around an Ethereum contract.
  4403  type ERC20BurnableCaller struct {
  4404  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  4405  }
  4406  
  4407  // ERC20BurnableTransactor is an auto generated write-only Go binding around an Ethereum contract.
  4408  type ERC20BurnableTransactor struct {
  4409  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  4410  }
  4411  
  4412  // ERC20BurnableFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  4413  type ERC20BurnableFilterer struct {
  4414  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  4415  }
  4416  
  4417  // ERC20BurnableSession is an auto generated Go binding around an Ethereum contract,
  4418  // with pre-set call and transact options.
  4419  type ERC20BurnableSession struct {
  4420  	Contract     *ERC20Burnable    // Generic contract binding to set the session for
  4421  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  4422  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  4423  }
  4424  
  4425  // ERC20BurnableCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  4426  // with pre-set call options.
  4427  type ERC20BurnableCallerSession struct {
  4428  	Contract *ERC20BurnableCaller // Generic contract caller binding to set the session for
  4429  	CallOpts bind.CallOpts        // Call options to use throughout this session
  4430  }
  4431  
  4432  // ERC20BurnableTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  4433  // with pre-set transact options.
  4434  type ERC20BurnableTransactorSession struct {
  4435  	Contract     *ERC20BurnableTransactor // Generic contract transactor binding to set the session for
  4436  	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
  4437  }
  4438  
  4439  // ERC20BurnableRaw is an auto generated low-level Go binding around an Ethereum contract.
  4440  type ERC20BurnableRaw struct {
  4441  	Contract *ERC20Burnable // Generic contract binding to access the raw methods on
  4442  }
  4443  
  4444  // ERC20BurnableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  4445  type ERC20BurnableCallerRaw struct {
  4446  	Contract *ERC20BurnableCaller // Generic read-only contract binding to access the raw methods on
  4447  }
  4448  
  4449  // ERC20BurnableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  4450  type ERC20BurnableTransactorRaw struct {
  4451  	Contract *ERC20BurnableTransactor // Generic write-only contract binding to access the raw methods on
  4452  }
  4453  
  4454  // NewERC20Burnable creates a new instance of ERC20Burnable, bound to a specific deployed contract.
  4455  func NewERC20Burnable(address common.Address, backend bind.ContractBackend) (*ERC20Burnable, error) {
  4456  	contract, err := bindERC20Burnable(address, backend, backend, backend)
  4457  	if err != nil {
  4458  		return nil, err
  4459  	}
  4460  	return &ERC20Burnable{ERC20BurnableCaller: ERC20BurnableCaller{contract: contract}, ERC20BurnableTransactor: ERC20BurnableTransactor{contract: contract}, ERC20BurnableFilterer: ERC20BurnableFilterer{contract: contract}}, nil
  4461  }
  4462  
  4463  // NewERC20BurnableCaller creates a new read-only instance of ERC20Burnable, bound to a specific deployed contract.
  4464  func NewERC20BurnableCaller(address common.Address, caller bind.ContractCaller) (*ERC20BurnableCaller, error) {
  4465  	contract, err := bindERC20Burnable(address, caller, nil, nil)
  4466  	if err != nil {
  4467  		return nil, err
  4468  	}
  4469  	return &ERC20BurnableCaller{contract: contract}, nil
  4470  }
  4471  
  4472  // NewERC20BurnableTransactor creates a new write-only instance of ERC20Burnable, bound to a specific deployed contract.
  4473  func NewERC20BurnableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20BurnableTransactor, error) {
  4474  	contract, err := bindERC20Burnable(address, nil, transactor, nil)
  4475  	if err != nil {
  4476  		return nil, err
  4477  	}
  4478  	return &ERC20BurnableTransactor{contract: contract}, nil
  4479  }
  4480  
  4481  // NewERC20BurnableFilterer creates a new log filterer instance of ERC20Burnable, bound to a specific deployed contract.
  4482  func NewERC20BurnableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20BurnableFilterer, error) {
  4483  	contract, err := bindERC20Burnable(address, nil, nil, filterer)
  4484  	if err != nil {
  4485  		return nil, err
  4486  	}
  4487  	return &ERC20BurnableFilterer{contract: contract}, nil
  4488  }
  4489  
  4490  // bindERC20Burnable binds a generic wrapper to an already deployed contract.
  4491  func bindERC20Burnable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  4492  	parsed, err := abi.JSON(strings.NewReader(ERC20BurnableABI))
  4493  	if err != nil {
  4494  		return nil, err
  4495  	}
  4496  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  4497  }
  4498  
  4499  // Call invokes the (constant) contract method with params as input values and
  4500  // sets the output to result. The result type might be a single field for simple
  4501  // returns, a slice of interfaces for anonymous returns and a struct for named
  4502  // returns.
  4503  func (_ERC20Burnable *ERC20BurnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  4504  	return _ERC20Burnable.Contract.ERC20BurnableCaller.contract.Call(opts, result, method, params...)
  4505  }
  4506  
  4507  // Transfer initiates a plain transaction to move funds to the contract, calling
  4508  // its default method if one is available.
  4509  func (_ERC20Burnable *ERC20BurnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  4510  	return _ERC20Burnable.Contract.ERC20BurnableTransactor.contract.Transfer(opts)
  4511  }
  4512  
  4513  // Transact invokes the (paid) contract method with params as input values.
  4514  func (_ERC20Burnable *ERC20BurnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  4515  	return _ERC20Burnable.Contract.ERC20BurnableTransactor.contract.Transact(opts, method, params...)
  4516  }
  4517  
  4518  // Call invokes the (constant) contract method with params as input values and
  4519  // sets the output to result. The result type might be a single field for simple
  4520  // returns, a slice of interfaces for anonymous returns and a struct for named
  4521  // returns.
  4522  func (_ERC20Burnable *ERC20BurnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  4523  	return _ERC20Burnable.Contract.contract.Call(opts, result, method, params...)
  4524  }
  4525  
  4526  // Transfer initiates a plain transaction to move funds to the contract, calling
  4527  // its default method if one is available.
  4528  func (_ERC20Burnable *ERC20BurnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  4529  	return _ERC20Burnable.Contract.contract.Transfer(opts)
  4530  }
  4531  
  4532  // Transact invokes the (paid) contract method with params as input values.
  4533  func (_ERC20Burnable *ERC20BurnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  4534  	return _ERC20Burnable.Contract.contract.Transact(opts, method, params...)
  4535  }
  4536  
  4537  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  4538  //
  4539  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  4540  func (_ERC20Burnable *ERC20BurnableCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
  4541  	var (
  4542  		ret0 = new(*big.Int)
  4543  	)
  4544  	out := ret0
  4545  	err := _ERC20Burnable.contract.Call(opts, out, "allowance", owner, spender)
  4546  	return *ret0, err
  4547  }
  4548  
  4549  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  4550  //
  4551  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  4552  func (_ERC20Burnable *ERC20BurnableSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  4553  	return _ERC20Burnable.Contract.Allowance(&_ERC20Burnable.CallOpts, owner, spender)
  4554  }
  4555  
  4556  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  4557  //
  4558  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  4559  func (_ERC20Burnable *ERC20BurnableCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  4560  	return _ERC20Burnable.Contract.Allowance(&_ERC20Burnable.CallOpts, owner, spender)
  4561  }
  4562  
  4563  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  4564  //
  4565  // Solidity: function balanceOf(address account) constant returns(uint256)
  4566  func (_ERC20Burnable *ERC20BurnableCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  4567  	var (
  4568  		ret0 = new(*big.Int)
  4569  	)
  4570  	out := ret0
  4571  	err := _ERC20Burnable.contract.Call(opts, out, "balanceOf", account)
  4572  	return *ret0, err
  4573  }
  4574  
  4575  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  4576  //
  4577  // Solidity: function balanceOf(address account) constant returns(uint256)
  4578  func (_ERC20Burnable *ERC20BurnableSession) BalanceOf(account common.Address) (*big.Int, error) {
  4579  	return _ERC20Burnable.Contract.BalanceOf(&_ERC20Burnable.CallOpts, account)
  4580  }
  4581  
  4582  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  4583  //
  4584  // Solidity: function balanceOf(address account) constant returns(uint256)
  4585  func (_ERC20Burnable *ERC20BurnableCallerSession) BalanceOf(account common.Address) (*big.Int, error) {
  4586  	return _ERC20Burnable.Contract.BalanceOf(&_ERC20Burnable.CallOpts, account)
  4587  }
  4588  
  4589  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  4590  //
  4591  // Solidity: function totalSupply() constant returns(uint256)
  4592  func (_ERC20Burnable *ERC20BurnableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
  4593  	var (
  4594  		ret0 = new(*big.Int)
  4595  	)
  4596  	out := ret0
  4597  	err := _ERC20Burnable.contract.Call(opts, out, "totalSupply")
  4598  	return *ret0, err
  4599  }
  4600  
  4601  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  4602  //
  4603  // Solidity: function totalSupply() constant returns(uint256)
  4604  func (_ERC20Burnable *ERC20BurnableSession) TotalSupply() (*big.Int, error) {
  4605  	return _ERC20Burnable.Contract.TotalSupply(&_ERC20Burnable.CallOpts)
  4606  }
  4607  
  4608  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  4609  //
  4610  // Solidity: function totalSupply() constant returns(uint256)
  4611  func (_ERC20Burnable *ERC20BurnableCallerSession) TotalSupply() (*big.Int, error) {
  4612  	return _ERC20Burnable.Contract.TotalSupply(&_ERC20Burnable.CallOpts)
  4613  }
  4614  
  4615  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  4616  //
  4617  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  4618  func (_ERC20Burnable *ERC20BurnableTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
  4619  	return _ERC20Burnable.contract.Transact(opts, "approve", spender, amount)
  4620  }
  4621  
  4622  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  4623  //
  4624  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  4625  func (_ERC20Burnable *ERC20BurnableSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  4626  	return _ERC20Burnable.Contract.Approve(&_ERC20Burnable.TransactOpts, spender, amount)
  4627  }
  4628  
  4629  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  4630  //
  4631  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  4632  func (_ERC20Burnable *ERC20BurnableTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  4633  	return _ERC20Burnable.Contract.Approve(&_ERC20Burnable.TransactOpts, spender, amount)
  4634  }
  4635  
  4636  // Burn is a paid mutator transaction binding the contract method 0x42966c68.
  4637  //
  4638  // Solidity: function burn(uint256 amount) returns()
  4639  func (_ERC20Burnable *ERC20BurnableTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) {
  4640  	return _ERC20Burnable.contract.Transact(opts, "burn", amount)
  4641  }
  4642  
  4643  // Burn is a paid mutator transaction binding the contract method 0x42966c68.
  4644  //
  4645  // Solidity: function burn(uint256 amount) returns()
  4646  func (_ERC20Burnable *ERC20BurnableSession) Burn(amount *big.Int) (*types.Transaction, error) {
  4647  	return _ERC20Burnable.Contract.Burn(&_ERC20Burnable.TransactOpts, amount)
  4648  }
  4649  
  4650  // Burn is a paid mutator transaction binding the contract method 0x42966c68.
  4651  //
  4652  // Solidity: function burn(uint256 amount) returns()
  4653  func (_ERC20Burnable *ERC20BurnableTransactorSession) Burn(amount *big.Int) (*types.Transaction, error) {
  4654  	return _ERC20Burnable.Contract.Burn(&_ERC20Burnable.TransactOpts, amount)
  4655  }
  4656  
  4657  // BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
  4658  //
  4659  // Solidity: function burnFrom(address account, uint256 amount) returns()
  4660  func (_ERC20Burnable *ERC20BurnableTransactor) BurnFrom(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) {
  4661  	return _ERC20Burnable.contract.Transact(opts, "burnFrom", account, amount)
  4662  }
  4663  
  4664  // BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
  4665  //
  4666  // Solidity: function burnFrom(address account, uint256 amount) returns()
  4667  func (_ERC20Burnable *ERC20BurnableSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) {
  4668  	return _ERC20Burnable.Contract.BurnFrom(&_ERC20Burnable.TransactOpts, account, amount)
  4669  }
  4670  
  4671  // BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
  4672  //
  4673  // Solidity: function burnFrom(address account, uint256 amount) returns()
  4674  func (_ERC20Burnable *ERC20BurnableTransactorSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) {
  4675  	return _ERC20Burnable.Contract.BurnFrom(&_ERC20Burnable.TransactOpts, account, amount)
  4676  }
  4677  
  4678  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  4679  //
  4680  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  4681  func (_ERC20Burnable *ERC20BurnableTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  4682  	return _ERC20Burnable.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
  4683  }
  4684  
  4685  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  4686  //
  4687  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  4688  func (_ERC20Burnable *ERC20BurnableSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  4689  	return _ERC20Burnable.Contract.DecreaseAllowance(&_ERC20Burnable.TransactOpts, spender, subtractedValue)
  4690  }
  4691  
  4692  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  4693  //
  4694  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  4695  func (_ERC20Burnable *ERC20BurnableTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  4696  	return _ERC20Burnable.Contract.DecreaseAllowance(&_ERC20Burnable.TransactOpts, spender, subtractedValue)
  4697  }
  4698  
  4699  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  4700  //
  4701  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  4702  func (_ERC20Burnable *ERC20BurnableTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  4703  	return _ERC20Burnable.contract.Transact(opts, "increaseAllowance", spender, addedValue)
  4704  }
  4705  
  4706  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  4707  //
  4708  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  4709  func (_ERC20Burnable *ERC20BurnableSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  4710  	return _ERC20Burnable.Contract.IncreaseAllowance(&_ERC20Burnable.TransactOpts, spender, addedValue)
  4711  }
  4712  
  4713  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  4714  //
  4715  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  4716  func (_ERC20Burnable *ERC20BurnableTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  4717  	return _ERC20Burnable.Contract.IncreaseAllowance(&_ERC20Burnable.TransactOpts, spender, addedValue)
  4718  }
  4719  
  4720  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  4721  //
  4722  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  4723  func (_ERC20Burnable *ERC20BurnableTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4724  	return _ERC20Burnable.contract.Transact(opts, "transfer", recipient, amount)
  4725  }
  4726  
  4727  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  4728  //
  4729  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  4730  func (_ERC20Burnable *ERC20BurnableSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4731  	return _ERC20Burnable.Contract.Transfer(&_ERC20Burnable.TransactOpts, recipient, amount)
  4732  }
  4733  
  4734  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  4735  //
  4736  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  4737  func (_ERC20Burnable *ERC20BurnableTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4738  	return _ERC20Burnable.Contract.Transfer(&_ERC20Burnable.TransactOpts, recipient, amount)
  4739  }
  4740  
  4741  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  4742  //
  4743  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  4744  func (_ERC20Burnable *ERC20BurnableTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4745  	return _ERC20Burnable.contract.Transact(opts, "transferFrom", sender, recipient, amount)
  4746  }
  4747  
  4748  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  4749  //
  4750  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  4751  func (_ERC20Burnable *ERC20BurnableSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4752  	return _ERC20Burnable.Contract.TransferFrom(&_ERC20Burnable.TransactOpts, sender, recipient, amount)
  4753  }
  4754  
  4755  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  4756  //
  4757  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  4758  func (_ERC20Burnable *ERC20BurnableTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  4759  	return _ERC20Burnable.Contract.TransferFrom(&_ERC20Burnable.TransactOpts, sender, recipient, amount)
  4760  }
  4761  
  4762  // ERC20BurnableApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20Burnable contract.
  4763  type ERC20BurnableApprovalIterator struct {
  4764  	Event *ERC20BurnableApproval // Event containing the contract specifics and raw log
  4765  
  4766  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  4767  	event    string              // Event name to use for unpacking event data
  4768  
  4769  	logs chan types.Log        // Log channel receiving the found contract events
  4770  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  4771  	done bool                  // Whether the subscription completed delivering logs
  4772  	fail error                 // Occurred error to stop iteration
  4773  }
  4774  
  4775  // Next advances the iterator to the subsequent event, returning whether there
  4776  // are any more events found. In case of a retrieval or parsing error, false is
  4777  // returned and Error() can be queried for the exact failure.
  4778  func (it *ERC20BurnableApprovalIterator) Next() bool {
  4779  	// If the iterator failed, stop iterating
  4780  	if it.fail != nil {
  4781  		return false
  4782  	}
  4783  	// If the iterator completed, deliver directly whatever's available
  4784  	if it.done {
  4785  		select {
  4786  		case log := <-it.logs:
  4787  			it.Event = new(ERC20BurnableApproval)
  4788  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4789  				it.fail = err
  4790  				return false
  4791  			}
  4792  			it.Event.Raw = log
  4793  			return true
  4794  
  4795  		default:
  4796  			return false
  4797  		}
  4798  	}
  4799  	// Iterator still in progress, wait for either a data or an error event
  4800  	select {
  4801  	case log := <-it.logs:
  4802  		it.Event = new(ERC20BurnableApproval)
  4803  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4804  			it.fail = err
  4805  			return false
  4806  		}
  4807  		it.Event.Raw = log
  4808  		return true
  4809  
  4810  	case err := <-it.sub.Err():
  4811  		it.done = true
  4812  		it.fail = err
  4813  		return it.Next()
  4814  	}
  4815  }
  4816  
  4817  // Error returns any retrieval or parsing error occurred during filtering.
  4818  func (it *ERC20BurnableApprovalIterator) Error() error {
  4819  	return it.fail
  4820  }
  4821  
  4822  // Close terminates the iteration process, releasing any pending underlying
  4823  // resources.
  4824  func (it *ERC20BurnableApprovalIterator) Close() error {
  4825  	it.sub.Unsubscribe()
  4826  	return nil
  4827  }
  4828  
  4829  // ERC20BurnableApproval represents a Approval event raised by the ERC20Burnable contract.
  4830  type ERC20BurnableApproval struct {
  4831  	Owner   common.Address
  4832  	Spender common.Address
  4833  	Value   *big.Int
  4834  	Raw     types.Log // Blockchain specific contextual infos
  4835  }
  4836  
  4837  // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  4838  //
  4839  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  4840  func (_ERC20Burnable *ERC20BurnableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20BurnableApprovalIterator, error) {
  4841  
  4842  	var ownerRule []interface{}
  4843  	for _, ownerItem := range owner {
  4844  		ownerRule = append(ownerRule, ownerItem)
  4845  	}
  4846  	var spenderRule []interface{}
  4847  	for _, spenderItem := range spender {
  4848  		spenderRule = append(spenderRule, spenderItem)
  4849  	}
  4850  
  4851  	logs, sub, err := _ERC20Burnable.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
  4852  	if err != nil {
  4853  		return nil, err
  4854  	}
  4855  	return &ERC20BurnableApprovalIterator{contract: _ERC20Burnable.contract, event: "Approval", logs: logs, sub: sub}, nil
  4856  }
  4857  
  4858  // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  4859  //
  4860  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  4861  func (_ERC20Burnable *ERC20BurnableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20BurnableApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
  4862  
  4863  	var ownerRule []interface{}
  4864  	for _, ownerItem := range owner {
  4865  		ownerRule = append(ownerRule, ownerItem)
  4866  	}
  4867  	var spenderRule []interface{}
  4868  	for _, spenderItem := range spender {
  4869  		spenderRule = append(spenderRule, spenderItem)
  4870  	}
  4871  
  4872  	logs, sub, err := _ERC20Burnable.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
  4873  	if err != nil {
  4874  		return nil, err
  4875  	}
  4876  	return event.NewSubscription(func(quit <-chan struct{}) error {
  4877  		defer sub.Unsubscribe()
  4878  		for {
  4879  			select {
  4880  			case log := <-logs:
  4881  				// New log arrived, parse the event and forward to the user
  4882  				event := new(ERC20BurnableApproval)
  4883  				if err := _ERC20Burnable.contract.UnpackLog(event, "Approval", log); err != nil {
  4884  					return err
  4885  				}
  4886  				event.Raw = log
  4887  
  4888  				select {
  4889  				case sink <- event:
  4890  				case err := <-sub.Err():
  4891  					return err
  4892  				case <-quit:
  4893  					return nil
  4894  				}
  4895  			case err := <-sub.Err():
  4896  				return err
  4897  			case <-quit:
  4898  				return nil
  4899  			}
  4900  		}
  4901  	}), nil
  4902  }
  4903  
  4904  // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  4905  //
  4906  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  4907  func (_ERC20Burnable *ERC20BurnableFilterer) ParseApproval(log types.Log) (*ERC20BurnableApproval, error) {
  4908  	event := new(ERC20BurnableApproval)
  4909  	if err := _ERC20Burnable.contract.UnpackLog(event, "Approval", log); err != nil {
  4910  		return nil, err
  4911  	}
  4912  	return event, nil
  4913  }
  4914  
  4915  // ERC20BurnableTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20Burnable contract.
  4916  type ERC20BurnableTransferIterator struct {
  4917  	Event *ERC20BurnableTransfer // Event containing the contract specifics and raw log
  4918  
  4919  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  4920  	event    string              // Event name to use for unpacking event data
  4921  
  4922  	logs chan types.Log        // Log channel receiving the found contract events
  4923  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  4924  	done bool                  // Whether the subscription completed delivering logs
  4925  	fail error                 // Occurred error to stop iteration
  4926  }
  4927  
  4928  // Next advances the iterator to the subsequent event, returning whether there
  4929  // are any more events found. In case of a retrieval or parsing error, false is
  4930  // returned and Error() can be queried for the exact failure.
  4931  func (it *ERC20BurnableTransferIterator) Next() bool {
  4932  	// If the iterator failed, stop iterating
  4933  	if it.fail != nil {
  4934  		return false
  4935  	}
  4936  	// If the iterator completed, deliver directly whatever's available
  4937  	if it.done {
  4938  		select {
  4939  		case log := <-it.logs:
  4940  			it.Event = new(ERC20BurnableTransfer)
  4941  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4942  				it.fail = err
  4943  				return false
  4944  			}
  4945  			it.Event.Raw = log
  4946  			return true
  4947  
  4948  		default:
  4949  			return false
  4950  		}
  4951  	}
  4952  	// Iterator still in progress, wait for either a data or an error event
  4953  	select {
  4954  	case log := <-it.logs:
  4955  		it.Event = new(ERC20BurnableTransfer)
  4956  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  4957  			it.fail = err
  4958  			return false
  4959  		}
  4960  		it.Event.Raw = log
  4961  		return true
  4962  
  4963  	case err := <-it.sub.Err():
  4964  		it.done = true
  4965  		it.fail = err
  4966  		return it.Next()
  4967  	}
  4968  }
  4969  
  4970  // Error returns any retrieval or parsing error occurred during filtering.
  4971  func (it *ERC20BurnableTransferIterator) Error() error {
  4972  	return it.fail
  4973  }
  4974  
  4975  // Close terminates the iteration process, releasing any pending underlying
  4976  // resources.
  4977  func (it *ERC20BurnableTransferIterator) Close() error {
  4978  	it.sub.Unsubscribe()
  4979  	return nil
  4980  }
  4981  
  4982  // ERC20BurnableTransfer represents a Transfer event raised by the ERC20Burnable contract.
  4983  type ERC20BurnableTransfer struct {
  4984  	From  common.Address
  4985  	To    common.Address
  4986  	Value *big.Int
  4987  	Raw   types.Log // Blockchain specific contextual infos
  4988  }
  4989  
  4990  // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  4991  //
  4992  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  4993  func (_ERC20Burnable *ERC20BurnableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20BurnableTransferIterator, error) {
  4994  
  4995  	var fromRule []interface{}
  4996  	for _, fromItem := range from {
  4997  		fromRule = append(fromRule, fromItem)
  4998  	}
  4999  	var toRule []interface{}
  5000  	for _, toItem := range to {
  5001  		toRule = append(toRule, toItem)
  5002  	}
  5003  
  5004  	logs, sub, err := _ERC20Burnable.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
  5005  	if err != nil {
  5006  		return nil, err
  5007  	}
  5008  	return &ERC20BurnableTransferIterator{contract: _ERC20Burnable.contract, event: "Transfer", logs: logs, sub: sub}, nil
  5009  }
  5010  
  5011  // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  5012  //
  5013  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  5014  func (_ERC20Burnable *ERC20BurnableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20BurnableTransfer, from []common.Address, to []common.Address) (event.Subscription, error) {
  5015  
  5016  	var fromRule []interface{}
  5017  	for _, fromItem := range from {
  5018  		fromRule = append(fromRule, fromItem)
  5019  	}
  5020  	var toRule []interface{}
  5021  	for _, toItem := range to {
  5022  		toRule = append(toRule, toItem)
  5023  	}
  5024  
  5025  	logs, sub, err := _ERC20Burnable.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
  5026  	if err != nil {
  5027  		return nil, err
  5028  	}
  5029  	return event.NewSubscription(func(quit <-chan struct{}) error {
  5030  		defer sub.Unsubscribe()
  5031  		for {
  5032  			select {
  5033  			case log := <-logs:
  5034  				// New log arrived, parse the event and forward to the user
  5035  				event := new(ERC20BurnableTransfer)
  5036  				if err := _ERC20Burnable.contract.UnpackLog(event, "Transfer", log); err != nil {
  5037  					return err
  5038  				}
  5039  				event.Raw = log
  5040  
  5041  				select {
  5042  				case sink <- event:
  5043  				case err := <-sub.Err():
  5044  					return err
  5045  				case <-quit:
  5046  					return nil
  5047  				}
  5048  			case err := <-sub.Err():
  5049  				return err
  5050  			case <-quit:
  5051  				return nil
  5052  			}
  5053  		}
  5054  	}), nil
  5055  }
  5056  
  5057  // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  5058  //
  5059  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  5060  func (_ERC20Burnable *ERC20BurnableFilterer) ParseTransfer(log types.Log) (*ERC20BurnableTransfer, error) {
  5061  	event := new(ERC20BurnableTransfer)
  5062  	if err := _ERC20Burnable.contract.UnpackLog(event, "Transfer", log); err != nil {
  5063  		return nil, err
  5064  	}
  5065  	return event, nil
  5066  }
  5067  
  5068  // ERC20DetailedABI is the input ABI used to generate the binding from.
  5069  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\"}]"
  5070  
  5071  // ERC20DetailedFuncSigs maps the 4-byte function signature to its string representation.
  5072  var ERC20DetailedFuncSigs = map[string]string{
  5073  	"dd62ed3e": "allowance(address,address)",
  5074  	"095ea7b3": "approve(address,uint256)",
  5075  	"70a08231": "balanceOf(address)",
  5076  	"313ce567": "decimals()",
  5077  	"06fdde03": "name()",
  5078  	"95d89b41": "symbol()",
  5079  	"18160ddd": "totalSupply()",
  5080  	"a9059cbb": "transfer(address,uint256)",
  5081  	"23b872dd": "transferFrom(address,address,uint256)",
  5082  }
  5083  
  5084  // ERC20Detailed is an auto generated Go binding around an Ethereum contract.
  5085  type ERC20Detailed struct {
  5086  	ERC20DetailedCaller     // Read-only binding to the contract
  5087  	ERC20DetailedTransactor // Write-only binding to the contract
  5088  	ERC20DetailedFilterer   // Log filterer for contract events
  5089  }
  5090  
  5091  // ERC20DetailedCaller is an auto generated read-only Go binding around an Ethereum contract.
  5092  type ERC20DetailedCaller struct {
  5093  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5094  }
  5095  
  5096  // ERC20DetailedTransactor is an auto generated write-only Go binding around an Ethereum contract.
  5097  type ERC20DetailedTransactor struct {
  5098  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5099  }
  5100  
  5101  // ERC20DetailedFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  5102  type ERC20DetailedFilterer struct {
  5103  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5104  }
  5105  
  5106  // ERC20DetailedSession is an auto generated Go binding around an Ethereum contract,
  5107  // with pre-set call and transact options.
  5108  type ERC20DetailedSession struct {
  5109  	Contract     *ERC20Detailed    // Generic contract binding to set the session for
  5110  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  5111  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  5112  }
  5113  
  5114  // ERC20DetailedCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  5115  // with pre-set call options.
  5116  type ERC20DetailedCallerSession struct {
  5117  	Contract *ERC20DetailedCaller // Generic contract caller binding to set the session for
  5118  	CallOpts bind.CallOpts        // Call options to use throughout this session
  5119  }
  5120  
  5121  // ERC20DetailedTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  5122  // with pre-set transact options.
  5123  type ERC20DetailedTransactorSession struct {
  5124  	Contract     *ERC20DetailedTransactor // Generic contract transactor binding to set the session for
  5125  	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
  5126  }
  5127  
  5128  // ERC20DetailedRaw is an auto generated low-level Go binding around an Ethereum contract.
  5129  type ERC20DetailedRaw struct {
  5130  	Contract *ERC20Detailed // Generic contract binding to access the raw methods on
  5131  }
  5132  
  5133  // ERC20DetailedCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  5134  type ERC20DetailedCallerRaw struct {
  5135  	Contract *ERC20DetailedCaller // Generic read-only contract binding to access the raw methods on
  5136  }
  5137  
  5138  // ERC20DetailedTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  5139  type ERC20DetailedTransactorRaw struct {
  5140  	Contract *ERC20DetailedTransactor // Generic write-only contract binding to access the raw methods on
  5141  }
  5142  
  5143  // NewERC20Detailed creates a new instance of ERC20Detailed, bound to a specific deployed contract.
  5144  func NewERC20Detailed(address common.Address, backend bind.ContractBackend) (*ERC20Detailed, error) {
  5145  	contract, err := bindERC20Detailed(address, backend, backend, backend)
  5146  	if err != nil {
  5147  		return nil, err
  5148  	}
  5149  	return &ERC20Detailed{ERC20DetailedCaller: ERC20DetailedCaller{contract: contract}, ERC20DetailedTransactor: ERC20DetailedTransactor{contract: contract}, ERC20DetailedFilterer: ERC20DetailedFilterer{contract: contract}}, nil
  5150  }
  5151  
  5152  // NewERC20DetailedCaller creates a new read-only instance of ERC20Detailed, bound to a specific deployed contract.
  5153  func NewERC20DetailedCaller(address common.Address, caller bind.ContractCaller) (*ERC20DetailedCaller, error) {
  5154  	contract, err := bindERC20Detailed(address, caller, nil, nil)
  5155  	if err != nil {
  5156  		return nil, err
  5157  	}
  5158  	return &ERC20DetailedCaller{contract: contract}, nil
  5159  }
  5160  
  5161  // NewERC20DetailedTransactor creates a new write-only instance of ERC20Detailed, bound to a specific deployed contract.
  5162  func NewERC20DetailedTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20DetailedTransactor, error) {
  5163  	contract, err := bindERC20Detailed(address, nil, transactor, nil)
  5164  	if err != nil {
  5165  		return nil, err
  5166  	}
  5167  	return &ERC20DetailedTransactor{contract: contract}, nil
  5168  }
  5169  
  5170  // NewERC20DetailedFilterer creates a new log filterer instance of ERC20Detailed, bound to a specific deployed contract.
  5171  func NewERC20DetailedFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20DetailedFilterer, error) {
  5172  	contract, err := bindERC20Detailed(address, nil, nil, filterer)
  5173  	if err != nil {
  5174  		return nil, err
  5175  	}
  5176  	return &ERC20DetailedFilterer{contract: contract}, nil
  5177  }
  5178  
  5179  // bindERC20Detailed binds a generic wrapper to an already deployed contract.
  5180  func bindERC20Detailed(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  5181  	parsed, err := abi.JSON(strings.NewReader(ERC20DetailedABI))
  5182  	if err != nil {
  5183  		return nil, err
  5184  	}
  5185  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  5186  }
  5187  
  5188  // Call invokes the (constant) contract method with params as input values and
  5189  // sets the output to result. The result type might be a single field for simple
  5190  // returns, a slice of interfaces for anonymous returns and a struct for named
  5191  // returns.
  5192  func (_ERC20Detailed *ERC20DetailedRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  5193  	return _ERC20Detailed.Contract.ERC20DetailedCaller.contract.Call(opts, result, method, params...)
  5194  }
  5195  
  5196  // Transfer initiates a plain transaction to move funds to the contract, calling
  5197  // its default method if one is available.
  5198  func (_ERC20Detailed *ERC20DetailedRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  5199  	return _ERC20Detailed.Contract.ERC20DetailedTransactor.contract.Transfer(opts)
  5200  }
  5201  
  5202  // Transact invokes the (paid) contract method with params as input values.
  5203  func (_ERC20Detailed *ERC20DetailedRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  5204  	return _ERC20Detailed.Contract.ERC20DetailedTransactor.contract.Transact(opts, method, params...)
  5205  }
  5206  
  5207  // Call invokes the (constant) contract method with params as input values and
  5208  // sets the output to result. The result type might be a single field for simple
  5209  // returns, a slice of interfaces for anonymous returns and a struct for named
  5210  // returns.
  5211  func (_ERC20Detailed *ERC20DetailedCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  5212  	return _ERC20Detailed.Contract.contract.Call(opts, result, method, params...)
  5213  }
  5214  
  5215  // Transfer initiates a plain transaction to move funds to the contract, calling
  5216  // its default method if one is available.
  5217  func (_ERC20Detailed *ERC20DetailedTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  5218  	return _ERC20Detailed.Contract.contract.Transfer(opts)
  5219  }
  5220  
  5221  // Transact invokes the (paid) contract method with params as input values.
  5222  func (_ERC20Detailed *ERC20DetailedTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  5223  	return _ERC20Detailed.Contract.contract.Transact(opts, method, params...)
  5224  }
  5225  
  5226  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  5227  //
  5228  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  5229  func (_ERC20Detailed *ERC20DetailedCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
  5230  	var (
  5231  		ret0 = new(*big.Int)
  5232  	)
  5233  	out := ret0
  5234  	err := _ERC20Detailed.contract.Call(opts, out, "allowance", owner, spender)
  5235  	return *ret0, err
  5236  }
  5237  
  5238  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  5239  //
  5240  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  5241  func (_ERC20Detailed *ERC20DetailedSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  5242  	return _ERC20Detailed.Contract.Allowance(&_ERC20Detailed.CallOpts, owner, spender)
  5243  }
  5244  
  5245  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  5246  //
  5247  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  5248  func (_ERC20Detailed *ERC20DetailedCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  5249  	return _ERC20Detailed.Contract.Allowance(&_ERC20Detailed.CallOpts, owner, spender)
  5250  }
  5251  
  5252  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  5253  //
  5254  // Solidity: function balanceOf(address account) constant returns(uint256)
  5255  func (_ERC20Detailed *ERC20DetailedCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  5256  	var (
  5257  		ret0 = new(*big.Int)
  5258  	)
  5259  	out := ret0
  5260  	err := _ERC20Detailed.contract.Call(opts, out, "balanceOf", account)
  5261  	return *ret0, err
  5262  }
  5263  
  5264  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  5265  //
  5266  // Solidity: function balanceOf(address account) constant returns(uint256)
  5267  func (_ERC20Detailed *ERC20DetailedSession) BalanceOf(account common.Address) (*big.Int, error) {
  5268  	return _ERC20Detailed.Contract.BalanceOf(&_ERC20Detailed.CallOpts, account)
  5269  }
  5270  
  5271  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  5272  //
  5273  // Solidity: function balanceOf(address account) constant returns(uint256)
  5274  func (_ERC20Detailed *ERC20DetailedCallerSession) BalanceOf(account common.Address) (*big.Int, error) {
  5275  	return _ERC20Detailed.Contract.BalanceOf(&_ERC20Detailed.CallOpts, account)
  5276  }
  5277  
  5278  // Decimals is a free data retrieval call binding the contract method 0x313ce567.
  5279  //
  5280  // Solidity: function decimals() constant returns(uint8)
  5281  func (_ERC20Detailed *ERC20DetailedCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
  5282  	var (
  5283  		ret0 = new(uint8)
  5284  	)
  5285  	out := ret0
  5286  	err := _ERC20Detailed.contract.Call(opts, out, "decimals")
  5287  	return *ret0, err
  5288  }
  5289  
  5290  // Decimals is a free data retrieval call binding the contract method 0x313ce567.
  5291  //
  5292  // Solidity: function decimals() constant returns(uint8)
  5293  func (_ERC20Detailed *ERC20DetailedSession) Decimals() (uint8, error) {
  5294  	return _ERC20Detailed.Contract.Decimals(&_ERC20Detailed.CallOpts)
  5295  }
  5296  
  5297  // Decimals is a free data retrieval call binding the contract method 0x313ce567.
  5298  //
  5299  // Solidity: function decimals() constant returns(uint8)
  5300  func (_ERC20Detailed *ERC20DetailedCallerSession) Decimals() (uint8, error) {
  5301  	return _ERC20Detailed.Contract.Decimals(&_ERC20Detailed.CallOpts)
  5302  }
  5303  
  5304  // Name is a free data retrieval call binding the contract method 0x06fdde03.
  5305  //
  5306  // Solidity: function name() constant returns(string)
  5307  func (_ERC20Detailed *ERC20DetailedCaller) Name(opts *bind.CallOpts) (string, error) {
  5308  	var (
  5309  		ret0 = new(string)
  5310  	)
  5311  	out := ret0
  5312  	err := _ERC20Detailed.contract.Call(opts, out, "name")
  5313  	return *ret0, err
  5314  }
  5315  
  5316  // Name is a free data retrieval call binding the contract method 0x06fdde03.
  5317  //
  5318  // Solidity: function name() constant returns(string)
  5319  func (_ERC20Detailed *ERC20DetailedSession) Name() (string, error) {
  5320  	return _ERC20Detailed.Contract.Name(&_ERC20Detailed.CallOpts)
  5321  }
  5322  
  5323  // Name is a free data retrieval call binding the contract method 0x06fdde03.
  5324  //
  5325  // Solidity: function name() constant returns(string)
  5326  func (_ERC20Detailed *ERC20DetailedCallerSession) Name() (string, error) {
  5327  	return _ERC20Detailed.Contract.Name(&_ERC20Detailed.CallOpts)
  5328  }
  5329  
  5330  // Symbol is a free data retrieval call binding the contract method 0x95d89b41.
  5331  //
  5332  // Solidity: function symbol() constant returns(string)
  5333  func (_ERC20Detailed *ERC20DetailedCaller) Symbol(opts *bind.CallOpts) (string, error) {
  5334  	var (
  5335  		ret0 = new(string)
  5336  	)
  5337  	out := ret0
  5338  	err := _ERC20Detailed.contract.Call(opts, out, "symbol")
  5339  	return *ret0, err
  5340  }
  5341  
  5342  // Symbol is a free data retrieval call binding the contract method 0x95d89b41.
  5343  //
  5344  // Solidity: function symbol() constant returns(string)
  5345  func (_ERC20Detailed *ERC20DetailedSession) Symbol() (string, error) {
  5346  	return _ERC20Detailed.Contract.Symbol(&_ERC20Detailed.CallOpts)
  5347  }
  5348  
  5349  // Symbol is a free data retrieval call binding the contract method 0x95d89b41.
  5350  //
  5351  // Solidity: function symbol() constant returns(string)
  5352  func (_ERC20Detailed *ERC20DetailedCallerSession) Symbol() (string, error) {
  5353  	return _ERC20Detailed.Contract.Symbol(&_ERC20Detailed.CallOpts)
  5354  }
  5355  
  5356  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  5357  //
  5358  // Solidity: function totalSupply() constant returns(uint256)
  5359  func (_ERC20Detailed *ERC20DetailedCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
  5360  	var (
  5361  		ret0 = new(*big.Int)
  5362  	)
  5363  	out := ret0
  5364  	err := _ERC20Detailed.contract.Call(opts, out, "totalSupply")
  5365  	return *ret0, err
  5366  }
  5367  
  5368  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  5369  //
  5370  // Solidity: function totalSupply() constant returns(uint256)
  5371  func (_ERC20Detailed *ERC20DetailedSession) TotalSupply() (*big.Int, error) {
  5372  	return _ERC20Detailed.Contract.TotalSupply(&_ERC20Detailed.CallOpts)
  5373  }
  5374  
  5375  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  5376  //
  5377  // Solidity: function totalSupply() constant returns(uint256)
  5378  func (_ERC20Detailed *ERC20DetailedCallerSession) TotalSupply() (*big.Int, error) {
  5379  	return _ERC20Detailed.Contract.TotalSupply(&_ERC20Detailed.CallOpts)
  5380  }
  5381  
  5382  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  5383  //
  5384  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  5385  func (_ERC20Detailed *ERC20DetailedTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
  5386  	return _ERC20Detailed.contract.Transact(opts, "approve", spender, amount)
  5387  }
  5388  
  5389  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  5390  //
  5391  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  5392  func (_ERC20Detailed *ERC20DetailedSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  5393  	return _ERC20Detailed.Contract.Approve(&_ERC20Detailed.TransactOpts, spender, amount)
  5394  }
  5395  
  5396  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  5397  //
  5398  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  5399  func (_ERC20Detailed *ERC20DetailedTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  5400  	return _ERC20Detailed.Contract.Approve(&_ERC20Detailed.TransactOpts, spender, amount)
  5401  }
  5402  
  5403  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  5404  //
  5405  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  5406  func (_ERC20Detailed *ERC20DetailedTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  5407  	return _ERC20Detailed.contract.Transact(opts, "transfer", recipient, amount)
  5408  }
  5409  
  5410  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  5411  //
  5412  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  5413  func (_ERC20Detailed *ERC20DetailedSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  5414  	return _ERC20Detailed.Contract.Transfer(&_ERC20Detailed.TransactOpts, recipient, amount)
  5415  }
  5416  
  5417  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  5418  //
  5419  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  5420  func (_ERC20Detailed *ERC20DetailedTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  5421  	return _ERC20Detailed.Contract.Transfer(&_ERC20Detailed.TransactOpts, recipient, amount)
  5422  }
  5423  
  5424  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  5425  //
  5426  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  5427  func (_ERC20Detailed *ERC20DetailedTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  5428  	return _ERC20Detailed.contract.Transact(opts, "transferFrom", sender, recipient, amount)
  5429  }
  5430  
  5431  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  5432  //
  5433  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  5434  func (_ERC20Detailed *ERC20DetailedSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  5435  	return _ERC20Detailed.Contract.TransferFrom(&_ERC20Detailed.TransactOpts, sender, recipient, amount)
  5436  }
  5437  
  5438  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  5439  //
  5440  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  5441  func (_ERC20Detailed *ERC20DetailedTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  5442  	return _ERC20Detailed.Contract.TransferFrom(&_ERC20Detailed.TransactOpts, sender, recipient, amount)
  5443  }
  5444  
  5445  // 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.
  5446  type ERC20DetailedApprovalIterator struct {
  5447  	Event *ERC20DetailedApproval // Event containing the contract specifics and raw log
  5448  
  5449  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  5450  	event    string              // Event name to use for unpacking event data
  5451  
  5452  	logs chan types.Log        // Log channel receiving the found contract events
  5453  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  5454  	done bool                  // Whether the subscription completed delivering logs
  5455  	fail error                 // Occurred error to stop iteration
  5456  }
  5457  
  5458  // Next advances the iterator to the subsequent event, returning whether there
  5459  // are any more events found. In case of a retrieval or parsing error, false is
  5460  // returned and Error() can be queried for the exact failure.
  5461  func (it *ERC20DetailedApprovalIterator) Next() bool {
  5462  	// If the iterator failed, stop iterating
  5463  	if it.fail != nil {
  5464  		return false
  5465  	}
  5466  	// If the iterator completed, deliver directly whatever's available
  5467  	if it.done {
  5468  		select {
  5469  		case log := <-it.logs:
  5470  			it.Event = new(ERC20DetailedApproval)
  5471  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  5472  				it.fail = err
  5473  				return false
  5474  			}
  5475  			it.Event.Raw = log
  5476  			return true
  5477  
  5478  		default:
  5479  			return false
  5480  		}
  5481  	}
  5482  	// Iterator still in progress, wait for either a data or an error event
  5483  	select {
  5484  	case log := <-it.logs:
  5485  		it.Event = new(ERC20DetailedApproval)
  5486  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  5487  			it.fail = err
  5488  			return false
  5489  		}
  5490  		it.Event.Raw = log
  5491  		return true
  5492  
  5493  	case err := <-it.sub.Err():
  5494  		it.done = true
  5495  		it.fail = err
  5496  		return it.Next()
  5497  	}
  5498  }
  5499  
  5500  // Error returns any retrieval or parsing error occurred during filtering.
  5501  func (it *ERC20DetailedApprovalIterator) Error() error {
  5502  	return it.fail
  5503  }
  5504  
  5505  // Close terminates the iteration process, releasing any pending underlying
  5506  // resources.
  5507  func (it *ERC20DetailedApprovalIterator) Close() error {
  5508  	it.sub.Unsubscribe()
  5509  	return nil
  5510  }
  5511  
  5512  // ERC20DetailedApproval represents a Approval event raised by the ERC20Detailed contract.
  5513  type ERC20DetailedApproval struct {
  5514  	Owner   common.Address
  5515  	Spender common.Address
  5516  	Value   *big.Int
  5517  	Raw     types.Log // Blockchain specific contextual infos
  5518  }
  5519  
  5520  // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  5521  //
  5522  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  5523  func (_ERC20Detailed *ERC20DetailedFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20DetailedApprovalIterator, error) {
  5524  
  5525  	var ownerRule []interface{}
  5526  	for _, ownerItem := range owner {
  5527  		ownerRule = append(ownerRule, ownerItem)
  5528  	}
  5529  	var spenderRule []interface{}
  5530  	for _, spenderItem := range spender {
  5531  		spenderRule = append(spenderRule, spenderItem)
  5532  	}
  5533  
  5534  	logs, sub, err := _ERC20Detailed.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
  5535  	if err != nil {
  5536  		return nil, err
  5537  	}
  5538  	return &ERC20DetailedApprovalIterator{contract: _ERC20Detailed.contract, event: "Approval", logs: logs, sub: sub}, nil
  5539  }
  5540  
  5541  // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  5542  //
  5543  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  5544  func (_ERC20Detailed *ERC20DetailedFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20DetailedApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
  5545  
  5546  	var ownerRule []interface{}
  5547  	for _, ownerItem := range owner {
  5548  		ownerRule = append(ownerRule, ownerItem)
  5549  	}
  5550  	var spenderRule []interface{}
  5551  	for _, spenderItem := range spender {
  5552  		spenderRule = append(spenderRule, spenderItem)
  5553  	}
  5554  
  5555  	logs, sub, err := _ERC20Detailed.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
  5556  	if err != nil {
  5557  		return nil, err
  5558  	}
  5559  	return event.NewSubscription(func(quit <-chan struct{}) error {
  5560  		defer sub.Unsubscribe()
  5561  		for {
  5562  			select {
  5563  			case log := <-logs:
  5564  				// New log arrived, parse the event and forward to the user
  5565  				event := new(ERC20DetailedApproval)
  5566  				if err := _ERC20Detailed.contract.UnpackLog(event, "Approval", log); err != nil {
  5567  					return err
  5568  				}
  5569  				event.Raw = log
  5570  
  5571  				select {
  5572  				case sink <- event:
  5573  				case err := <-sub.Err():
  5574  					return err
  5575  				case <-quit:
  5576  					return nil
  5577  				}
  5578  			case err := <-sub.Err():
  5579  				return err
  5580  			case <-quit:
  5581  				return nil
  5582  			}
  5583  		}
  5584  	}), nil
  5585  }
  5586  
  5587  // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  5588  //
  5589  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  5590  func (_ERC20Detailed *ERC20DetailedFilterer) ParseApproval(log types.Log) (*ERC20DetailedApproval, error) {
  5591  	event := new(ERC20DetailedApproval)
  5592  	if err := _ERC20Detailed.contract.UnpackLog(event, "Approval", log); err != nil {
  5593  		return nil, err
  5594  	}
  5595  	return event, nil
  5596  }
  5597  
  5598  // 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.
  5599  type ERC20DetailedTransferIterator struct {
  5600  	Event *ERC20DetailedTransfer // Event containing the contract specifics and raw log
  5601  
  5602  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  5603  	event    string              // Event name to use for unpacking event data
  5604  
  5605  	logs chan types.Log        // Log channel receiving the found contract events
  5606  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  5607  	done bool                  // Whether the subscription completed delivering logs
  5608  	fail error                 // Occurred error to stop iteration
  5609  }
  5610  
  5611  // Next advances the iterator to the subsequent event, returning whether there
  5612  // are any more events found. In case of a retrieval or parsing error, false is
  5613  // returned and Error() can be queried for the exact failure.
  5614  func (it *ERC20DetailedTransferIterator) Next() bool {
  5615  	// If the iterator failed, stop iterating
  5616  	if it.fail != nil {
  5617  		return false
  5618  	}
  5619  	// If the iterator completed, deliver directly whatever's available
  5620  	if it.done {
  5621  		select {
  5622  		case log := <-it.logs:
  5623  			it.Event = new(ERC20DetailedTransfer)
  5624  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  5625  				it.fail = err
  5626  				return false
  5627  			}
  5628  			it.Event.Raw = log
  5629  			return true
  5630  
  5631  		default:
  5632  			return false
  5633  		}
  5634  	}
  5635  	// Iterator still in progress, wait for either a data or an error event
  5636  	select {
  5637  	case log := <-it.logs:
  5638  		it.Event = new(ERC20DetailedTransfer)
  5639  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  5640  			it.fail = err
  5641  			return false
  5642  		}
  5643  		it.Event.Raw = log
  5644  		return true
  5645  
  5646  	case err := <-it.sub.Err():
  5647  		it.done = true
  5648  		it.fail = err
  5649  		return it.Next()
  5650  	}
  5651  }
  5652  
  5653  // Error returns any retrieval or parsing error occurred during filtering.
  5654  func (it *ERC20DetailedTransferIterator) Error() error {
  5655  	return it.fail
  5656  }
  5657  
  5658  // Close terminates the iteration process, releasing any pending underlying
  5659  // resources.
  5660  func (it *ERC20DetailedTransferIterator) Close() error {
  5661  	it.sub.Unsubscribe()
  5662  	return nil
  5663  }
  5664  
  5665  // ERC20DetailedTransfer represents a Transfer event raised by the ERC20Detailed contract.
  5666  type ERC20DetailedTransfer struct {
  5667  	From  common.Address
  5668  	To    common.Address
  5669  	Value *big.Int
  5670  	Raw   types.Log // Blockchain specific contextual infos
  5671  }
  5672  
  5673  // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  5674  //
  5675  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  5676  func (_ERC20Detailed *ERC20DetailedFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20DetailedTransferIterator, error) {
  5677  
  5678  	var fromRule []interface{}
  5679  	for _, fromItem := range from {
  5680  		fromRule = append(fromRule, fromItem)
  5681  	}
  5682  	var toRule []interface{}
  5683  	for _, toItem := range to {
  5684  		toRule = append(toRule, toItem)
  5685  	}
  5686  
  5687  	logs, sub, err := _ERC20Detailed.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
  5688  	if err != nil {
  5689  		return nil, err
  5690  	}
  5691  	return &ERC20DetailedTransferIterator{contract: _ERC20Detailed.contract, event: "Transfer", logs: logs, sub: sub}, nil
  5692  }
  5693  
  5694  // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  5695  //
  5696  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  5697  func (_ERC20Detailed *ERC20DetailedFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20DetailedTransfer, from []common.Address, to []common.Address) (event.Subscription, error) {
  5698  
  5699  	var fromRule []interface{}
  5700  	for _, fromItem := range from {
  5701  		fromRule = append(fromRule, fromItem)
  5702  	}
  5703  	var toRule []interface{}
  5704  	for _, toItem := range to {
  5705  		toRule = append(toRule, toItem)
  5706  	}
  5707  
  5708  	logs, sub, err := _ERC20Detailed.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
  5709  	if err != nil {
  5710  		return nil, err
  5711  	}
  5712  	return event.NewSubscription(func(quit <-chan struct{}) error {
  5713  		defer sub.Unsubscribe()
  5714  		for {
  5715  			select {
  5716  			case log := <-logs:
  5717  				// New log arrived, parse the event and forward to the user
  5718  				event := new(ERC20DetailedTransfer)
  5719  				if err := _ERC20Detailed.contract.UnpackLog(event, "Transfer", log); err != nil {
  5720  					return err
  5721  				}
  5722  				event.Raw = log
  5723  
  5724  				select {
  5725  				case sink <- event:
  5726  				case err := <-sub.Err():
  5727  					return err
  5728  				case <-quit:
  5729  					return nil
  5730  				}
  5731  			case err := <-sub.Err():
  5732  				return err
  5733  			case <-quit:
  5734  				return nil
  5735  			}
  5736  		}
  5737  	}), nil
  5738  }
  5739  
  5740  // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  5741  //
  5742  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  5743  func (_ERC20Detailed *ERC20DetailedFilterer) ParseTransfer(log types.Log) (*ERC20DetailedTransfer, error) {
  5744  	event := new(ERC20DetailedTransfer)
  5745  	if err := _ERC20Detailed.contract.UnpackLog(event, "Transfer", log); err != nil {
  5746  		return nil, err
  5747  	}
  5748  	return event, nil
  5749  }
  5750  
  5751  // ERC20MintableABI is the input ABI used to generate the binding from.
  5752  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\"}]"
  5753  
  5754  // ERC20MintableFuncSigs maps the 4-byte function signature to its string representation.
  5755  var ERC20MintableFuncSigs = map[string]string{
  5756  	"983b2d56": "addMinter(address)",
  5757  	"dd62ed3e": "allowance(address,address)",
  5758  	"095ea7b3": "approve(address,uint256)",
  5759  	"70a08231": "balanceOf(address)",
  5760  	"a457c2d7": "decreaseAllowance(address,uint256)",
  5761  	"39509351": "increaseAllowance(address,uint256)",
  5762  	"aa271e1a": "isMinter(address)",
  5763  	"40c10f19": "mint(address,uint256)",
  5764  	"98650275": "renounceMinter()",
  5765  	"18160ddd": "totalSupply()",
  5766  	"a9059cbb": "transfer(address,uint256)",
  5767  	"23b872dd": "transferFrom(address,address,uint256)",
  5768  }
  5769  
  5770  // ERC20MintableBin is the compiled bytecode used for deploying new contracts.
  5771  var ERC20MintableBin = "0x60806040526100266100186001600160e01b0361002b16565b6001600160e01b0361002f16565b6101a3565b3390565b61004781600361007e60201b610a6e1790919060201c565b6040516001600160a01b038216907f6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f690600090a250565b61009182826001600160e01b0361012216565b156100fd57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f526f6c65733a206163636f756e7420616c72656164792068617320726f6c6500604482015290519081900360640190fd5b6001600160a01b0316600090815260209190915260409020805460ff19166001179055565b60006001600160a01b038216610183576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526022815260200180610eb16022913960400191505060405180910390fd5b506001600160a01b03166000908152602091909152604090205460ff1690565b610cff806101b26000396000f3fe608060405234801561001057600080fd5b50600436106100b45760003560e01c8063983b2d5611610071578063983b2d56146101c757806398650275146101ef578063a457c2d7146101f7578063a9059cbb14610223578063aa271e1a1461024f578063dd62ed3e14610275576100b4565b8063095ea7b3146100b957806318160ddd146100f957806323b872dd14610113578063395093511461014957806340c10f191461017557806370a08231146101a1575b600080fd5b6100e5600480360360408110156100cf57600080fd5b506001600160a01b0381351690602001356102a3565b604080519115158252519081900360200190f35b6101016102c0565b60408051918252519081900360200190f35b6100e56004803603606081101561012957600080fd5b506001600160a01b038135811691602081013590911690604001356102c6565b6100e56004803603604081101561015f57600080fd5b506001600160a01b038135169060200135610353565b6100e56004803603604081101561018b57600080fd5b506001600160a01b0381351690602001356103a7565b610101600480360360208110156101b757600080fd5b50356001600160a01b03166103fe565b6101ed600480360360208110156101dd57600080fd5b50356001600160a01b0316610419565b005b6101ed61046b565b6100e56004803603604081101561020d57600080fd5b506001600160a01b03813516906020013561047d565b6100e56004803603604081101561023957600080fd5b506001600160a01b0381351690602001356104eb565b6100e56004803603602081101561026557600080fd5b50356001600160a01b03166104ff565b6101016004803603604081101561028b57600080fd5b506001600160a01b0381358116916020013516610518565b60006102b76102b0610543565b8484610547565b50600192915050565b60025490565b60006102d3848484610633565b610349846102df610543565b61034485604051806060016040528060288152602001610c13602891396001600160a01b038a1660009081526001602052604081209061031d610543565b6001600160a01b03168152602081019190915260400160002054919063ffffffff61078f16565b610547565b5060019392505050565b60006102b7610360610543565b846103448560016000610371610543565b6001600160a01b03908116825260208083019390935260409182016000908120918c16815292529020549063ffffffff61082616565b60006103b96103b4610543565b6104ff565b6103f45760405162461bcd60e51b8152600401808060200182810382526030815260200180610bc26030913960400191505060405180910390fd5b6102b78383610887565b6001600160a01b031660009081526020819052604090205490565b6104246103b4610543565b61045f5760405162461bcd60e51b8152600401808060200182810382526030815260200180610bc26030913960400191505060405180910390fd5b61046881610977565b50565b61047b610476610543565b6109bf565b565b60006102b761048a610543565b8461034485604051806060016040528060258152602001610ca660259139600160006104b4610543565b6001600160a01b03908116825260208083019390935260409182016000908120918d1681529252902054919063ffffffff61078f16565b60006102b76104f8610543565b8484610633565b600061051260038363ffffffff610a0716565b92915050565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b3390565b6001600160a01b03831661058c5760405162461bcd60e51b8152600401808060200182810382526024815260200180610c826024913960400191505060405180910390fd5b6001600160a01b0382166105d15760405162461bcd60e51b8152600401808060200182810382526022815260200180610b7a6022913960400191505060405180910390fd5b6001600160a01b03808416600081815260016020908152604080832094871680845294825291829020859055815185815291517f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259281900390910190a3505050565b6001600160a01b0383166106785760405162461bcd60e51b8152600401808060200182810382526025815260200180610c5d6025913960400191505060405180910390fd5b6001600160a01b0382166106bd5760405162461bcd60e51b8152600401808060200182810382526023815260200180610b576023913960400191505060405180910390fd5b61070081604051806060016040528060268152602001610b9c602691396001600160a01b038616600090815260208190526040902054919063ffffffff61078f16565b6001600160a01b038085166000908152602081905260408082209390935590841681522054610735908263ffffffff61082616565b6001600160a01b038084166000818152602081815260409182902094909455805185815290519193928716927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef92918290030190a3505050565b6000818484111561081e5760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b838110156107e35781810151838201526020016107cb565b50505050905090810190601f1680156108105780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b505050900390565b600082820183811015610880576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b9392505050565b6001600160a01b0382166108e2576040805162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f206164647265737300604482015290519081900360640190fd5b6002546108f5908263ffffffff61082616565b6002556001600160a01b038216600090815260208190526040902054610921908263ffffffff61082616565b6001600160a01b0383166000818152602081815260408083209490945583518581529351929391927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9281900390910190a35050565b61098860038263ffffffff610a6e16565b6040516001600160a01b038216907f6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f690600090a250565b6109d060038263ffffffff610aef16565b6040516001600160a01b038216907fe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb6669290600090a250565b60006001600160a01b038216610a4e5760405162461bcd60e51b8152600401808060200182810382526022815260200180610c3b6022913960400191505060405180910390fd5b506001600160a01b03166000908152602091909152604090205460ff1690565b610a788282610a07565b15610aca576040805162461bcd60e51b815260206004820152601f60248201527f526f6c65733a206163636f756e7420616c72656164792068617320726f6c6500604482015290519081900360640190fd5b6001600160a01b0316600090815260209190915260409020805460ff19166001179055565b610af98282610a07565b610b345760405162461bcd60e51b8152600401808060200182810382526021815260200180610bf26021913960400191505060405180910390fd5b6001600160a01b0316600090815260209190915260409020805460ff1916905556fe45524332303a207472616e7366657220746f20746865207a65726f206164647265737345524332303a20617070726f766520746f20746865207a65726f206164647265737345524332303a207472616e7366657220616d6f756e7420657863656564732062616c616e63654d696e746572526f6c653a2063616c6c657220646f6573206e6f74206861766520746865204d696e74657220726f6c65526f6c65733a206163636f756e7420646f6573206e6f74206861766520726f6c6545524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e6365526f6c65733a206163636f756e7420697320746865207a65726f206164647265737345524332303a207472616e736665722066726f6d20746865207a65726f206164647265737345524332303a20617070726f76652066726f6d20746865207a65726f206164647265737345524332303a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726fa265627a7a723158209bffbae26a8473ab446e60484fc8f37931f262c4c630ff4ea7ef2fd99a2a4ba364736f6c634300050c0032526f6c65733a206163636f756e7420697320746865207a65726f2061646472657373"
  5772  
  5773  // DeployERC20Mintable deploys a new Ethereum contract, binding an instance of ERC20Mintable to it.
  5774  func DeployERC20Mintable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20Mintable, error) {
  5775  	parsed, err := abi.JSON(strings.NewReader(ERC20MintableABI))
  5776  	if err != nil {
  5777  		return common.Address{}, nil, nil, err
  5778  	}
  5779  
  5780  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20MintableBin), backend)
  5781  	if err != nil {
  5782  		return common.Address{}, nil, nil, err
  5783  	}
  5784  	return address, tx, &ERC20Mintable{ERC20MintableCaller: ERC20MintableCaller{contract: contract}, ERC20MintableTransactor: ERC20MintableTransactor{contract: contract}, ERC20MintableFilterer: ERC20MintableFilterer{contract: contract}}, nil
  5785  }
  5786  
  5787  // ERC20Mintable is an auto generated Go binding around an Ethereum contract.
  5788  type ERC20Mintable struct {
  5789  	ERC20MintableCaller     // Read-only binding to the contract
  5790  	ERC20MintableTransactor // Write-only binding to the contract
  5791  	ERC20MintableFilterer   // Log filterer for contract events
  5792  }
  5793  
  5794  // ERC20MintableCaller is an auto generated read-only Go binding around an Ethereum contract.
  5795  type ERC20MintableCaller struct {
  5796  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5797  }
  5798  
  5799  // ERC20MintableTransactor is an auto generated write-only Go binding around an Ethereum contract.
  5800  type ERC20MintableTransactor struct {
  5801  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5802  }
  5803  
  5804  // ERC20MintableFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  5805  type ERC20MintableFilterer struct {
  5806  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  5807  }
  5808  
  5809  // ERC20MintableSession is an auto generated Go binding around an Ethereum contract,
  5810  // with pre-set call and transact options.
  5811  type ERC20MintableSession struct {
  5812  	Contract     *ERC20Mintable    // Generic contract binding to set the session for
  5813  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  5814  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  5815  }
  5816  
  5817  // ERC20MintableCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  5818  // with pre-set call options.
  5819  type ERC20MintableCallerSession struct {
  5820  	Contract *ERC20MintableCaller // Generic contract caller binding to set the session for
  5821  	CallOpts bind.CallOpts        // Call options to use throughout this session
  5822  }
  5823  
  5824  // ERC20MintableTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  5825  // with pre-set transact options.
  5826  type ERC20MintableTransactorSession struct {
  5827  	Contract     *ERC20MintableTransactor // Generic contract transactor binding to set the session for
  5828  	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
  5829  }
  5830  
  5831  // ERC20MintableRaw is an auto generated low-level Go binding around an Ethereum contract.
  5832  type ERC20MintableRaw struct {
  5833  	Contract *ERC20Mintable // Generic contract binding to access the raw methods on
  5834  }
  5835  
  5836  // ERC20MintableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  5837  type ERC20MintableCallerRaw struct {
  5838  	Contract *ERC20MintableCaller // Generic read-only contract binding to access the raw methods on
  5839  }
  5840  
  5841  // ERC20MintableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  5842  type ERC20MintableTransactorRaw struct {
  5843  	Contract *ERC20MintableTransactor // Generic write-only contract binding to access the raw methods on
  5844  }
  5845  
  5846  // NewERC20Mintable creates a new instance of ERC20Mintable, bound to a specific deployed contract.
  5847  func NewERC20Mintable(address common.Address, backend bind.ContractBackend) (*ERC20Mintable, error) {
  5848  	contract, err := bindERC20Mintable(address, backend, backend, backend)
  5849  	if err != nil {
  5850  		return nil, err
  5851  	}
  5852  	return &ERC20Mintable{ERC20MintableCaller: ERC20MintableCaller{contract: contract}, ERC20MintableTransactor: ERC20MintableTransactor{contract: contract}, ERC20MintableFilterer: ERC20MintableFilterer{contract: contract}}, nil
  5853  }
  5854  
  5855  // NewERC20MintableCaller creates a new read-only instance of ERC20Mintable, bound to a specific deployed contract.
  5856  func NewERC20MintableCaller(address common.Address, caller bind.ContractCaller) (*ERC20MintableCaller, error) {
  5857  	contract, err := bindERC20Mintable(address, caller, nil, nil)
  5858  	if err != nil {
  5859  		return nil, err
  5860  	}
  5861  	return &ERC20MintableCaller{contract: contract}, nil
  5862  }
  5863  
  5864  // NewERC20MintableTransactor creates a new write-only instance of ERC20Mintable, bound to a specific deployed contract.
  5865  func NewERC20MintableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20MintableTransactor, error) {
  5866  	contract, err := bindERC20Mintable(address, nil, transactor, nil)
  5867  	if err != nil {
  5868  		return nil, err
  5869  	}
  5870  	return &ERC20MintableTransactor{contract: contract}, nil
  5871  }
  5872  
  5873  // NewERC20MintableFilterer creates a new log filterer instance of ERC20Mintable, bound to a specific deployed contract.
  5874  func NewERC20MintableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20MintableFilterer, error) {
  5875  	contract, err := bindERC20Mintable(address, nil, nil, filterer)
  5876  	if err != nil {
  5877  		return nil, err
  5878  	}
  5879  	return &ERC20MintableFilterer{contract: contract}, nil
  5880  }
  5881  
  5882  // bindERC20Mintable binds a generic wrapper to an already deployed contract.
  5883  func bindERC20Mintable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  5884  	parsed, err := abi.JSON(strings.NewReader(ERC20MintableABI))
  5885  	if err != nil {
  5886  		return nil, err
  5887  	}
  5888  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  5889  }
  5890  
  5891  // Call invokes the (constant) contract method with params as input values and
  5892  // sets the output to result. The result type might be a single field for simple
  5893  // returns, a slice of interfaces for anonymous returns and a struct for named
  5894  // returns.
  5895  func (_ERC20Mintable *ERC20MintableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  5896  	return _ERC20Mintable.Contract.ERC20MintableCaller.contract.Call(opts, result, method, params...)
  5897  }
  5898  
  5899  // Transfer initiates a plain transaction to move funds to the contract, calling
  5900  // its default method if one is available.
  5901  func (_ERC20Mintable *ERC20MintableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  5902  	return _ERC20Mintable.Contract.ERC20MintableTransactor.contract.Transfer(opts)
  5903  }
  5904  
  5905  // Transact invokes the (paid) contract method with params as input values.
  5906  func (_ERC20Mintable *ERC20MintableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  5907  	return _ERC20Mintable.Contract.ERC20MintableTransactor.contract.Transact(opts, method, params...)
  5908  }
  5909  
  5910  // Call invokes the (constant) contract method with params as input values and
  5911  // sets the output to result. The result type might be a single field for simple
  5912  // returns, a slice of interfaces for anonymous returns and a struct for named
  5913  // returns.
  5914  func (_ERC20Mintable *ERC20MintableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  5915  	return _ERC20Mintable.Contract.contract.Call(opts, result, method, params...)
  5916  }
  5917  
  5918  // Transfer initiates a plain transaction to move funds to the contract, calling
  5919  // its default method if one is available.
  5920  func (_ERC20Mintable *ERC20MintableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  5921  	return _ERC20Mintable.Contract.contract.Transfer(opts)
  5922  }
  5923  
  5924  // Transact invokes the (paid) contract method with params as input values.
  5925  func (_ERC20Mintable *ERC20MintableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  5926  	return _ERC20Mintable.Contract.contract.Transact(opts, method, params...)
  5927  }
  5928  
  5929  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  5930  //
  5931  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  5932  func (_ERC20Mintable *ERC20MintableCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
  5933  	var (
  5934  		ret0 = new(*big.Int)
  5935  	)
  5936  	out := ret0
  5937  	err := _ERC20Mintable.contract.Call(opts, out, "allowance", owner, spender)
  5938  	return *ret0, err
  5939  }
  5940  
  5941  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  5942  //
  5943  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  5944  func (_ERC20Mintable *ERC20MintableSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  5945  	return _ERC20Mintable.Contract.Allowance(&_ERC20Mintable.CallOpts, owner, spender)
  5946  }
  5947  
  5948  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  5949  //
  5950  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  5951  func (_ERC20Mintable *ERC20MintableCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  5952  	return _ERC20Mintable.Contract.Allowance(&_ERC20Mintable.CallOpts, owner, spender)
  5953  }
  5954  
  5955  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  5956  //
  5957  // Solidity: function balanceOf(address account) constant returns(uint256)
  5958  func (_ERC20Mintable *ERC20MintableCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  5959  	var (
  5960  		ret0 = new(*big.Int)
  5961  	)
  5962  	out := ret0
  5963  	err := _ERC20Mintable.contract.Call(opts, out, "balanceOf", account)
  5964  	return *ret0, err
  5965  }
  5966  
  5967  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  5968  //
  5969  // Solidity: function balanceOf(address account) constant returns(uint256)
  5970  func (_ERC20Mintable *ERC20MintableSession) BalanceOf(account common.Address) (*big.Int, error) {
  5971  	return _ERC20Mintable.Contract.BalanceOf(&_ERC20Mintable.CallOpts, account)
  5972  }
  5973  
  5974  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  5975  //
  5976  // Solidity: function balanceOf(address account) constant returns(uint256)
  5977  func (_ERC20Mintable *ERC20MintableCallerSession) BalanceOf(account common.Address) (*big.Int, error) {
  5978  	return _ERC20Mintable.Contract.BalanceOf(&_ERC20Mintable.CallOpts, account)
  5979  }
  5980  
  5981  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
  5982  //
  5983  // Solidity: function isMinter(address account) constant returns(bool)
  5984  func (_ERC20Mintable *ERC20MintableCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) {
  5985  	var (
  5986  		ret0 = new(bool)
  5987  	)
  5988  	out := ret0
  5989  	err := _ERC20Mintable.contract.Call(opts, out, "isMinter", account)
  5990  	return *ret0, err
  5991  }
  5992  
  5993  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
  5994  //
  5995  // Solidity: function isMinter(address account) constant returns(bool)
  5996  func (_ERC20Mintable *ERC20MintableSession) IsMinter(account common.Address) (bool, error) {
  5997  	return _ERC20Mintable.Contract.IsMinter(&_ERC20Mintable.CallOpts, account)
  5998  }
  5999  
  6000  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
  6001  //
  6002  // Solidity: function isMinter(address account) constant returns(bool)
  6003  func (_ERC20Mintable *ERC20MintableCallerSession) IsMinter(account common.Address) (bool, error) {
  6004  	return _ERC20Mintable.Contract.IsMinter(&_ERC20Mintable.CallOpts, account)
  6005  }
  6006  
  6007  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  6008  //
  6009  // Solidity: function totalSupply() constant returns(uint256)
  6010  func (_ERC20Mintable *ERC20MintableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
  6011  	var (
  6012  		ret0 = new(*big.Int)
  6013  	)
  6014  	out := ret0
  6015  	err := _ERC20Mintable.contract.Call(opts, out, "totalSupply")
  6016  	return *ret0, err
  6017  }
  6018  
  6019  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  6020  //
  6021  // Solidity: function totalSupply() constant returns(uint256)
  6022  func (_ERC20Mintable *ERC20MintableSession) TotalSupply() (*big.Int, error) {
  6023  	return _ERC20Mintable.Contract.TotalSupply(&_ERC20Mintable.CallOpts)
  6024  }
  6025  
  6026  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  6027  //
  6028  // Solidity: function totalSupply() constant returns(uint256)
  6029  func (_ERC20Mintable *ERC20MintableCallerSession) TotalSupply() (*big.Int, error) {
  6030  	return _ERC20Mintable.Contract.TotalSupply(&_ERC20Mintable.CallOpts)
  6031  }
  6032  
  6033  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
  6034  //
  6035  // Solidity: function addMinter(address account) returns()
  6036  func (_ERC20Mintable *ERC20MintableTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
  6037  	return _ERC20Mintable.contract.Transact(opts, "addMinter", account)
  6038  }
  6039  
  6040  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
  6041  //
  6042  // Solidity: function addMinter(address account) returns()
  6043  func (_ERC20Mintable *ERC20MintableSession) AddMinter(account common.Address) (*types.Transaction, error) {
  6044  	return _ERC20Mintable.Contract.AddMinter(&_ERC20Mintable.TransactOpts, account)
  6045  }
  6046  
  6047  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
  6048  //
  6049  // Solidity: function addMinter(address account) returns()
  6050  func (_ERC20Mintable *ERC20MintableTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) {
  6051  	return _ERC20Mintable.Contract.AddMinter(&_ERC20Mintable.TransactOpts, account)
  6052  }
  6053  
  6054  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  6055  //
  6056  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  6057  func (_ERC20Mintable *ERC20MintableTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
  6058  	return _ERC20Mintable.contract.Transact(opts, "approve", spender, amount)
  6059  }
  6060  
  6061  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  6062  //
  6063  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  6064  func (_ERC20Mintable *ERC20MintableSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  6065  	return _ERC20Mintable.Contract.Approve(&_ERC20Mintable.TransactOpts, spender, amount)
  6066  }
  6067  
  6068  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  6069  //
  6070  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  6071  func (_ERC20Mintable *ERC20MintableTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  6072  	return _ERC20Mintable.Contract.Approve(&_ERC20Mintable.TransactOpts, spender, amount)
  6073  }
  6074  
  6075  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  6076  //
  6077  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  6078  func (_ERC20Mintable *ERC20MintableTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  6079  	return _ERC20Mintable.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
  6080  }
  6081  
  6082  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  6083  //
  6084  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  6085  func (_ERC20Mintable *ERC20MintableSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  6086  	return _ERC20Mintable.Contract.DecreaseAllowance(&_ERC20Mintable.TransactOpts, spender, subtractedValue)
  6087  }
  6088  
  6089  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  6090  //
  6091  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  6092  func (_ERC20Mintable *ERC20MintableTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  6093  	return _ERC20Mintable.Contract.DecreaseAllowance(&_ERC20Mintable.TransactOpts, spender, subtractedValue)
  6094  }
  6095  
  6096  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  6097  //
  6098  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  6099  func (_ERC20Mintable *ERC20MintableTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  6100  	return _ERC20Mintable.contract.Transact(opts, "increaseAllowance", spender, addedValue)
  6101  }
  6102  
  6103  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  6104  //
  6105  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  6106  func (_ERC20Mintable *ERC20MintableSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  6107  	return _ERC20Mintable.Contract.IncreaseAllowance(&_ERC20Mintable.TransactOpts, spender, addedValue)
  6108  }
  6109  
  6110  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  6111  //
  6112  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  6113  func (_ERC20Mintable *ERC20MintableTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  6114  	return _ERC20Mintable.Contract.IncreaseAllowance(&_ERC20Mintable.TransactOpts, spender, addedValue)
  6115  }
  6116  
  6117  // Mint is a paid mutator transaction binding the contract method 0x40c10f19.
  6118  //
  6119  // Solidity: function mint(address account, uint256 amount) returns(bool)
  6120  func (_ERC20Mintable *ERC20MintableTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) {
  6121  	return _ERC20Mintable.contract.Transact(opts, "mint", account, amount)
  6122  }
  6123  
  6124  // Mint is a paid mutator transaction binding the contract method 0x40c10f19.
  6125  //
  6126  // Solidity: function mint(address account, uint256 amount) returns(bool)
  6127  func (_ERC20Mintable *ERC20MintableSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
  6128  	return _ERC20Mintable.Contract.Mint(&_ERC20Mintable.TransactOpts, account, amount)
  6129  }
  6130  
  6131  // Mint is a paid mutator transaction binding the contract method 0x40c10f19.
  6132  //
  6133  // Solidity: function mint(address account, uint256 amount) returns(bool)
  6134  func (_ERC20Mintable *ERC20MintableTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
  6135  	return _ERC20Mintable.Contract.Mint(&_ERC20Mintable.TransactOpts, account, amount)
  6136  }
  6137  
  6138  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  6139  //
  6140  // Solidity: function renounceMinter() returns()
  6141  func (_ERC20Mintable *ERC20MintableTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) {
  6142  	return _ERC20Mintable.contract.Transact(opts, "renounceMinter")
  6143  }
  6144  
  6145  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  6146  //
  6147  // Solidity: function renounceMinter() returns()
  6148  func (_ERC20Mintable *ERC20MintableSession) RenounceMinter() (*types.Transaction, error) {
  6149  	return _ERC20Mintable.Contract.RenounceMinter(&_ERC20Mintable.TransactOpts)
  6150  }
  6151  
  6152  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  6153  //
  6154  // Solidity: function renounceMinter() returns()
  6155  func (_ERC20Mintable *ERC20MintableTransactorSession) RenounceMinter() (*types.Transaction, error) {
  6156  	return _ERC20Mintable.Contract.RenounceMinter(&_ERC20Mintable.TransactOpts)
  6157  }
  6158  
  6159  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  6160  //
  6161  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  6162  func (_ERC20Mintable *ERC20MintableTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  6163  	return _ERC20Mintable.contract.Transact(opts, "transfer", recipient, amount)
  6164  }
  6165  
  6166  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  6167  //
  6168  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  6169  func (_ERC20Mintable *ERC20MintableSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  6170  	return _ERC20Mintable.Contract.Transfer(&_ERC20Mintable.TransactOpts, recipient, amount)
  6171  }
  6172  
  6173  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  6174  //
  6175  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  6176  func (_ERC20Mintable *ERC20MintableTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  6177  	return _ERC20Mintable.Contract.Transfer(&_ERC20Mintable.TransactOpts, recipient, amount)
  6178  }
  6179  
  6180  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  6181  //
  6182  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  6183  func (_ERC20Mintable *ERC20MintableTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  6184  	return _ERC20Mintable.contract.Transact(opts, "transferFrom", sender, recipient, amount)
  6185  }
  6186  
  6187  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  6188  //
  6189  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  6190  func (_ERC20Mintable *ERC20MintableSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  6191  	return _ERC20Mintable.Contract.TransferFrom(&_ERC20Mintable.TransactOpts, sender, recipient, amount)
  6192  }
  6193  
  6194  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  6195  //
  6196  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  6197  func (_ERC20Mintable *ERC20MintableTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  6198  	return _ERC20Mintable.Contract.TransferFrom(&_ERC20Mintable.TransactOpts, sender, recipient, amount)
  6199  }
  6200  
  6201  // 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.
  6202  type ERC20MintableApprovalIterator struct {
  6203  	Event *ERC20MintableApproval // Event containing the contract specifics and raw log
  6204  
  6205  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  6206  	event    string              // Event name to use for unpacking event data
  6207  
  6208  	logs chan types.Log        // Log channel receiving the found contract events
  6209  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  6210  	done bool                  // Whether the subscription completed delivering logs
  6211  	fail error                 // Occurred error to stop iteration
  6212  }
  6213  
  6214  // Next advances the iterator to the subsequent event, returning whether there
  6215  // are any more events found. In case of a retrieval or parsing error, false is
  6216  // returned and Error() can be queried for the exact failure.
  6217  func (it *ERC20MintableApprovalIterator) Next() bool {
  6218  	// If the iterator failed, stop iterating
  6219  	if it.fail != nil {
  6220  		return false
  6221  	}
  6222  	// If the iterator completed, deliver directly whatever's available
  6223  	if it.done {
  6224  		select {
  6225  		case log := <-it.logs:
  6226  			it.Event = new(ERC20MintableApproval)
  6227  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  6228  				it.fail = err
  6229  				return false
  6230  			}
  6231  			it.Event.Raw = log
  6232  			return true
  6233  
  6234  		default:
  6235  			return false
  6236  		}
  6237  	}
  6238  	// Iterator still in progress, wait for either a data or an error event
  6239  	select {
  6240  	case log := <-it.logs:
  6241  		it.Event = new(ERC20MintableApproval)
  6242  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  6243  			it.fail = err
  6244  			return false
  6245  		}
  6246  		it.Event.Raw = log
  6247  		return true
  6248  
  6249  	case err := <-it.sub.Err():
  6250  		it.done = true
  6251  		it.fail = err
  6252  		return it.Next()
  6253  	}
  6254  }
  6255  
  6256  // Error returns any retrieval or parsing error occurred during filtering.
  6257  func (it *ERC20MintableApprovalIterator) Error() error {
  6258  	return it.fail
  6259  }
  6260  
  6261  // Close terminates the iteration process, releasing any pending underlying
  6262  // resources.
  6263  func (it *ERC20MintableApprovalIterator) Close() error {
  6264  	it.sub.Unsubscribe()
  6265  	return nil
  6266  }
  6267  
  6268  // ERC20MintableApproval represents a Approval event raised by the ERC20Mintable contract.
  6269  type ERC20MintableApproval struct {
  6270  	Owner   common.Address
  6271  	Spender common.Address
  6272  	Value   *big.Int
  6273  	Raw     types.Log // Blockchain specific contextual infos
  6274  }
  6275  
  6276  // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  6277  //
  6278  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  6279  func (_ERC20Mintable *ERC20MintableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20MintableApprovalIterator, error) {
  6280  
  6281  	var ownerRule []interface{}
  6282  	for _, ownerItem := range owner {
  6283  		ownerRule = append(ownerRule, ownerItem)
  6284  	}
  6285  	var spenderRule []interface{}
  6286  	for _, spenderItem := range spender {
  6287  		spenderRule = append(spenderRule, spenderItem)
  6288  	}
  6289  
  6290  	logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
  6291  	if err != nil {
  6292  		return nil, err
  6293  	}
  6294  	return &ERC20MintableApprovalIterator{contract: _ERC20Mintable.contract, event: "Approval", logs: logs, sub: sub}, nil
  6295  }
  6296  
  6297  // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  6298  //
  6299  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  6300  func (_ERC20Mintable *ERC20MintableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20MintableApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
  6301  
  6302  	var ownerRule []interface{}
  6303  	for _, ownerItem := range owner {
  6304  		ownerRule = append(ownerRule, ownerItem)
  6305  	}
  6306  	var spenderRule []interface{}
  6307  	for _, spenderItem := range spender {
  6308  		spenderRule = append(spenderRule, spenderItem)
  6309  	}
  6310  
  6311  	logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
  6312  	if err != nil {
  6313  		return nil, err
  6314  	}
  6315  	return event.NewSubscription(func(quit <-chan struct{}) error {
  6316  		defer sub.Unsubscribe()
  6317  		for {
  6318  			select {
  6319  			case log := <-logs:
  6320  				// New log arrived, parse the event and forward to the user
  6321  				event := new(ERC20MintableApproval)
  6322  				if err := _ERC20Mintable.contract.UnpackLog(event, "Approval", log); err != nil {
  6323  					return err
  6324  				}
  6325  				event.Raw = log
  6326  
  6327  				select {
  6328  				case sink <- event:
  6329  				case err := <-sub.Err():
  6330  					return err
  6331  				case <-quit:
  6332  					return nil
  6333  				}
  6334  			case err := <-sub.Err():
  6335  				return err
  6336  			case <-quit:
  6337  				return nil
  6338  			}
  6339  		}
  6340  	}), nil
  6341  }
  6342  
  6343  // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  6344  //
  6345  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  6346  func (_ERC20Mintable *ERC20MintableFilterer) ParseApproval(log types.Log) (*ERC20MintableApproval, error) {
  6347  	event := new(ERC20MintableApproval)
  6348  	if err := _ERC20Mintable.contract.UnpackLog(event, "Approval", log); err != nil {
  6349  		return nil, err
  6350  	}
  6351  	return event, nil
  6352  }
  6353  
  6354  // 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.
  6355  type ERC20MintableMinterAddedIterator struct {
  6356  	Event *ERC20MintableMinterAdded // Event containing the contract specifics and raw log
  6357  
  6358  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  6359  	event    string              // Event name to use for unpacking event data
  6360  
  6361  	logs chan types.Log        // Log channel receiving the found contract events
  6362  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  6363  	done bool                  // Whether the subscription completed delivering logs
  6364  	fail error                 // Occurred error to stop iteration
  6365  }
  6366  
  6367  // Next advances the iterator to the subsequent event, returning whether there
  6368  // are any more events found. In case of a retrieval or parsing error, false is
  6369  // returned and Error() can be queried for the exact failure.
  6370  func (it *ERC20MintableMinterAddedIterator) Next() bool {
  6371  	// If the iterator failed, stop iterating
  6372  	if it.fail != nil {
  6373  		return false
  6374  	}
  6375  	// If the iterator completed, deliver directly whatever's available
  6376  	if it.done {
  6377  		select {
  6378  		case log := <-it.logs:
  6379  			it.Event = new(ERC20MintableMinterAdded)
  6380  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  6381  				it.fail = err
  6382  				return false
  6383  			}
  6384  			it.Event.Raw = log
  6385  			return true
  6386  
  6387  		default:
  6388  			return false
  6389  		}
  6390  	}
  6391  	// Iterator still in progress, wait for either a data or an error event
  6392  	select {
  6393  	case log := <-it.logs:
  6394  		it.Event = new(ERC20MintableMinterAdded)
  6395  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  6396  			it.fail = err
  6397  			return false
  6398  		}
  6399  		it.Event.Raw = log
  6400  		return true
  6401  
  6402  	case err := <-it.sub.Err():
  6403  		it.done = true
  6404  		it.fail = err
  6405  		return it.Next()
  6406  	}
  6407  }
  6408  
  6409  // Error returns any retrieval or parsing error occurred during filtering.
  6410  func (it *ERC20MintableMinterAddedIterator) Error() error {
  6411  	return it.fail
  6412  }
  6413  
  6414  // Close terminates the iteration process, releasing any pending underlying
  6415  // resources.
  6416  func (it *ERC20MintableMinterAddedIterator) Close() error {
  6417  	it.sub.Unsubscribe()
  6418  	return nil
  6419  }
  6420  
  6421  // ERC20MintableMinterAdded represents a MinterAdded event raised by the ERC20Mintable contract.
  6422  type ERC20MintableMinterAdded struct {
  6423  	Account common.Address
  6424  	Raw     types.Log // Blockchain specific contextual infos
  6425  }
  6426  
  6427  // FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
  6428  //
  6429  // Solidity: event MinterAdded(address indexed account)
  6430  func (_ERC20Mintable *ERC20MintableFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*ERC20MintableMinterAddedIterator, error) {
  6431  
  6432  	var accountRule []interface{}
  6433  	for _, accountItem := range account {
  6434  		accountRule = append(accountRule, accountItem)
  6435  	}
  6436  
  6437  	logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "MinterAdded", accountRule)
  6438  	if err != nil {
  6439  		return nil, err
  6440  	}
  6441  	return &ERC20MintableMinterAddedIterator{contract: _ERC20Mintable.contract, event: "MinterAdded", logs: logs, sub: sub}, nil
  6442  }
  6443  
  6444  // WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
  6445  //
  6446  // Solidity: event MinterAdded(address indexed account)
  6447  func (_ERC20Mintable *ERC20MintableFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *ERC20MintableMinterAdded, account []common.Address) (event.Subscription, error) {
  6448  
  6449  	var accountRule []interface{}
  6450  	for _, accountItem := range account {
  6451  		accountRule = append(accountRule, accountItem)
  6452  	}
  6453  
  6454  	logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "MinterAdded", accountRule)
  6455  	if err != nil {
  6456  		return nil, err
  6457  	}
  6458  	return event.NewSubscription(func(quit <-chan struct{}) error {
  6459  		defer sub.Unsubscribe()
  6460  		for {
  6461  			select {
  6462  			case log := <-logs:
  6463  				// New log arrived, parse the event and forward to the user
  6464  				event := new(ERC20MintableMinterAdded)
  6465  				if err := _ERC20Mintable.contract.UnpackLog(event, "MinterAdded", log); err != nil {
  6466  					return err
  6467  				}
  6468  				event.Raw = log
  6469  
  6470  				select {
  6471  				case sink <- event:
  6472  				case err := <-sub.Err():
  6473  					return err
  6474  				case <-quit:
  6475  					return nil
  6476  				}
  6477  			case err := <-sub.Err():
  6478  				return err
  6479  			case <-quit:
  6480  				return nil
  6481  			}
  6482  		}
  6483  	}), nil
  6484  }
  6485  
  6486  // ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
  6487  //
  6488  // Solidity: event MinterAdded(address indexed account)
  6489  func (_ERC20Mintable *ERC20MintableFilterer) ParseMinterAdded(log types.Log) (*ERC20MintableMinterAdded, error) {
  6490  	event := new(ERC20MintableMinterAdded)
  6491  	if err := _ERC20Mintable.contract.UnpackLog(event, "MinterAdded", log); err != nil {
  6492  		return nil, err
  6493  	}
  6494  	return event, nil
  6495  }
  6496  
  6497  // 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.
  6498  type ERC20MintableMinterRemovedIterator struct {
  6499  	Event *ERC20MintableMinterRemoved // Event containing the contract specifics and raw log
  6500  
  6501  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  6502  	event    string              // Event name to use for unpacking event data
  6503  
  6504  	logs chan types.Log        // Log channel receiving the found contract events
  6505  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  6506  	done bool                  // Whether the subscription completed delivering logs
  6507  	fail error                 // Occurred error to stop iteration
  6508  }
  6509  
  6510  // Next advances the iterator to the subsequent event, returning whether there
  6511  // are any more events found. In case of a retrieval or parsing error, false is
  6512  // returned and Error() can be queried for the exact failure.
  6513  func (it *ERC20MintableMinterRemovedIterator) Next() bool {
  6514  	// If the iterator failed, stop iterating
  6515  	if it.fail != nil {
  6516  		return false
  6517  	}
  6518  	// If the iterator completed, deliver directly whatever's available
  6519  	if it.done {
  6520  		select {
  6521  		case log := <-it.logs:
  6522  			it.Event = new(ERC20MintableMinterRemoved)
  6523  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  6524  				it.fail = err
  6525  				return false
  6526  			}
  6527  			it.Event.Raw = log
  6528  			return true
  6529  
  6530  		default:
  6531  			return false
  6532  		}
  6533  	}
  6534  	// Iterator still in progress, wait for either a data or an error event
  6535  	select {
  6536  	case log := <-it.logs:
  6537  		it.Event = new(ERC20MintableMinterRemoved)
  6538  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  6539  			it.fail = err
  6540  			return false
  6541  		}
  6542  		it.Event.Raw = log
  6543  		return true
  6544  
  6545  	case err := <-it.sub.Err():
  6546  		it.done = true
  6547  		it.fail = err
  6548  		return it.Next()
  6549  	}
  6550  }
  6551  
  6552  // Error returns any retrieval or parsing error occurred during filtering.
  6553  func (it *ERC20MintableMinterRemovedIterator) Error() error {
  6554  	return it.fail
  6555  }
  6556  
  6557  // Close terminates the iteration process, releasing any pending underlying
  6558  // resources.
  6559  func (it *ERC20MintableMinterRemovedIterator) Close() error {
  6560  	it.sub.Unsubscribe()
  6561  	return nil
  6562  }
  6563  
  6564  // ERC20MintableMinterRemoved represents a MinterRemoved event raised by the ERC20Mintable contract.
  6565  type ERC20MintableMinterRemoved struct {
  6566  	Account common.Address
  6567  	Raw     types.Log // Blockchain specific contextual infos
  6568  }
  6569  
  6570  // FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
  6571  //
  6572  // Solidity: event MinterRemoved(address indexed account)
  6573  func (_ERC20Mintable *ERC20MintableFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*ERC20MintableMinterRemovedIterator, error) {
  6574  
  6575  	var accountRule []interface{}
  6576  	for _, accountItem := range account {
  6577  		accountRule = append(accountRule, accountItem)
  6578  	}
  6579  
  6580  	logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "MinterRemoved", accountRule)
  6581  	if err != nil {
  6582  		return nil, err
  6583  	}
  6584  	return &ERC20MintableMinterRemovedIterator{contract: _ERC20Mintable.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil
  6585  }
  6586  
  6587  // WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
  6588  //
  6589  // Solidity: event MinterRemoved(address indexed account)
  6590  func (_ERC20Mintable *ERC20MintableFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *ERC20MintableMinterRemoved, account []common.Address) (event.Subscription, error) {
  6591  
  6592  	var accountRule []interface{}
  6593  	for _, accountItem := range account {
  6594  		accountRule = append(accountRule, accountItem)
  6595  	}
  6596  
  6597  	logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "MinterRemoved", accountRule)
  6598  	if err != nil {
  6599  		return nil, err
  6600  	}
  6601  	return event.NewSubscription(func(quit <-chan struct{}) error {
  6602  		defer sub.Unsubscribe()
  6603  		for {
  6604  			select {
  6605  			case log := <-logs:
  6606  				// New log arrived, parse the event and forward to the user
  6607  				event := new(ERC20MintableMinterRemoved)
  6608  				if err := _ERC20Mintable.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
  6609  					return err
  6610  				}
  6611  				event.Raw = log
  6612  
  6613  				select {
  6614  				case sink <- event:
  6615  				case err := <-sub.Err():
  6616  					return err
  6617  				case <-quit:
  6618  					return nil
  6619  				}
  6620  			case err := <-sub.Err():
  6621  				return err
  6622  			case <-quit:
  6623  				return nil
  6624  			}
  6625  		}
  6626  	}), nil
  6627  }
  6628  
  6629  // ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
  6630  //
  6631  // Solidity: event MinterRemoved(address indexed account)
  6632  func (_ERC20Mintable *ERC20MintableFilterer) ParseMinterRemoved(log types.Log) (*ERC20MintableMinterRemoved, error) {
  6633  	event := new(ERC20MintableMinterRemoved)
  6634  	if err := _ERC20Mintable.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
  6635  		return nil, err
  6636  	}
  6637  	return event, nil
  6638  }
  6639  
  6640  // 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.
  6641  type ERC20MintableTransferIterator struct {
  6642  	Event *ERC20MintableTransfer // Event containing the contract specifics and raw log
  6643  
  6644  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  6645  	event    string              // Event name to use for unpacking event data
  6646  
  6647  	logs chan types.Log        // Log channel receiving the found contract events
  6648  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  6649  	done bool                  // Whether the subscription completed delivering logs
  6650  	fail error                 // Occurred error to stop iteration
  6651  }
  6652  
  6653  // Next advances the iterator to the subsequent event, returning whether there
  6654  // are any more events found. In case of a retrieval or parsing error, false is
  6655  // returned and Error() can be queried for the exact failure.
  6656  func (it *ERC20MintableTransferIterator) Next() bool {
  6657  	// If the iterator failed, stop iterating
  6658  	if it.fail != nil {
  6659  		return false
  6660  	}
  6661  	// If the iterator completed, deliver directly whatever's available
  6662  	if it.done {
  6663  		select {
  6664  		case log := <-it.logs:
  6665  			it.Event = new(ERC20MintableTransfer)
  6666  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  6667  				it.fail = err
  6668  				return false
  6669  			}
  6670  			it.Event.Raw = log
  6671  			return true
  6672  
  6673  		default:
  6674  			return false
  6675  		}
  6676  	}
  6677  	// Iterator still in progress, wait for either a data or an error event
  6678  	select {
  6679  	case log := <-it.logs:
  6680  		it.Event = new(ERC20MintableTransfer)
  6681  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  6682  			it.fail = err
  6683  			return false
  6684  		}
  6685  		it.Event.Raw = log
  6686  		return true
  6687  
  6688  	case err := <-it.sub.Err():
  6689  		it.done = true
  6690  		it.fail = err
  6691  		return it.Next()
  6692  	}
  6693  }
  6694  
  6695  // Error returns any retrieval or parsing error occurred during filtering.
  6696  func (it *ERC20MintableTransferIterator) Error() error {
  6697  	return it.fail
  6698  }
  6699  
  6700  // Close terminates the iteration process, releasing any pending underlying
  6701  // resources.
  6702  func (it *ERC20MintableTransferIterator) Close() error {
  6703  	it.sub.Unsubscribe()
  6704  	return nil
  6705  }
  6706  
  6707  // ERC20MintableTransfer represents a Transfer event raised by the ERC20Mintable contract.
  6708  type ERC20MintableTransfer struct {
  6709  	From  common.Address
  6710  	To    common.Address
  6711  	Value *big.Int
  6712  	Raw   types.Log // Blockchain specific contextual infos
  6713  }
  6714  
  6715  // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  6716  //
  6717  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  6718  func (_ERC20Mintable *ERC20MintableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20MintableTransferIterator, error) {
  6719  
  6720  	var fromRule []interface{}
  6721  	for _, fromItem := range from {
  6722  		fromRule = append(fromRule, fromItem)
  6723  	}
  6724  	var toRule []interface{}
  6725  	for _, toItem := range to {
  6726  		toRule = append(toRule, toItem)
  6727  	}
  6728  
  6729  	logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
  6730  	if err != nil {
  6731  		return nil, err
  6732  	}
  6733  	return &ERC20MintableTransferIterator{contract: _ERC20Mintable.contract, event: "Transfer", logs: logs, sub: sub}, nil
  6734  }
  6735  
  6736  // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  6737  //
  6738  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  6739  func (_ERC20Mintable *ERC20MintableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20MintableTransfer, from []common.Address, to []common.Address) (event.Subscription, error) {
  6740  
  6741  	var fromRule []interface{}
  6742  	for _, fromItem := range from {
  6743  		fromRule = append(fromRule, fromItem)
  6744  	}
  6745  	var toRule []interface{}
  6746  	for _, toItem := range to {
  6747  		toRule = append(toRule, toItem)
  6748  	}
  6749  
  6750  	logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
  6751  	if err != nil {
  6752  		return nil, err
  6753  	}
  6754  	return event.NewSubscription(func(quit <-chan struct{}) error {
  6755  		defer sub.Unsubscribe()
  6756  		for {
  6757  			select {
  6758  			case log := <-logs:
  6759  				// New log arrived, parse the event and forward to the user
  6760  				event := new(ERC20MintableTransfer)
  6761  				if err := _ERC20Mintable.contract.UnpackLog(event, "Transfer", log); err != nil {
  6762  					return err
  6763  				}
  6764  				event.Raw = log
  6765  
  6766  				select {
  6767  				case sink <- event:
  6768  				case err := <-sub.Err():
  6769  					return err
  6770  				case <-quit:
  6771  					return nil
  6772  				}
  6773  			case err := <-sub.Err():
  6774  				return err
  6775  			case <-quit:
  6776  				return nil
  6777  			}
  6778  		}
  6779  	}), nil
  6780  }
  6781  
  6782  // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  6783  //
  6784  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  6785  func (_ERC20Mintable *ERC20MintableFilterer) ParseTransfer(log types.Log) (*ERC20MintableTransfer, error) {
  6786  	event := new(ERC20MintableTransfer)
  6787  	if err := _ERC20Mintable.contract.UnpackLog(event, "Transfer", log); err != nil {
  6788  		return nil, err
  6789  	}
  6790  	return event, nil
  6791  }
  6792  
  6793  // ERC20OnApproveABI is the input ABI used to generate the binding from.
  6794  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\"}]"
  6795  
  6796  // ERC20OnApproveFuncSigs maps the 4-byte function signature to its string representation.
  6797  var ERC20OnApproveFuncSigs = map[string]string{
  6798  	"6cd28f9a": "INTERFACE_ID_ON_APPROVE()",
  6799  	"dd62ed3e": "allowance(address,address)",
  6800  	"095ea7b3": "approve(address,uint256)",
  6801  	"cae9ca51": "approveAndCall(address,uint256,bytes)",
  6802  	"70a08231": "balanceOf(address)",
  6803  	"a457c2d7": "decreaseAllowance(address,uint256)",
  6804  	"39509351": "increaseAllowance(address,uint256)",
  6805  	"18160ddd": "totalSupply()",
  6806  	"a9059cbb": "transfer(address,uint256)",
  6807  	"23b872dd": "transferFrom(address,address,uint256)",
  6808  }
  6809  
  6810  // ERC20OnApproveBin is the compiled bytecode used for deploying new contracts.
  6811  var ERC20OnApproveBin = "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"
  6812  
  6813  // DeployERC20OnApprove deploys a new Ethereum contract, binding an instance of ERC20OnApprove to it.
  6814  func DeployERC20OnApprove(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20OnApprove, error) {
  6815  	parsed, err := abi.JSON(strings.NewReader(ERC20OnApproveABI))
  6816  	if err != nil {
  6817  		return common.Address{}, nil, nil, err
  6818  	}
  6819  
  6820  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20OnApproveBin), backend)
  6821  	if err != nil {
  6822  		return common.Address{}, nil, nil, err
  6823  	}
  6824  	return address, tx, &ERC20OnApprove{ERC20OnApproveCaller: ERC20OnApproveCaller{contract: contract}, ERC20OnApproveTransactor: ERC20OnApproveTransactor{contract: contract}, ERC20OnApproveFilterer: ERC20OnApproveFilterer{contract: contract}}, nil
  6825  }
  6826  
  6827  // ERC20OnApprove is an auto generated Go binding around an Ethereum contract.
  6828  type ERC20OnApprove struct {
  6829  	ERC20OnApproveCaller     // Read-only binding to the contract
  6830  	ERC20OnApproveTransactor // Write-only binding to the contract
  6831  	ERC20OnApproveFilterer   // Log filterer for contract events
  6832  }
  6833  
  6834  // ERC20OnApproveCaller is an auto generated read-only Go binding around an Ethereum contract.
  6835  type ERC20OnApproveCaller struct {
  6836  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  6837  }
  6838  
  6839  // ERC20OnApproveTransactor is an auto generated write-only Go binding around an Ethereum contract.
  6840  type ERC20OnApproveTransactor struct {
  6841  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  6842  }
  6843  
  6844  // ERC20OnApproveFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  6845  type ERC20OnApproveFilterer struct {
  6846  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  6847  }
  6848  
  6849  // ERC20OnApproveSession is an auto generated Go binding around an Ethereum contract,
  6850  // with pre-set call and transact options.
  6851  type ERC20OnApproveSession struct {
  6852  	Contract     *ERC20OnApprove   // Generic contract binding to set the session for
  6853  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  6854  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  6855  }
  6856  
  6857  // ERC20OnApproveCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  6858  // with pre-set call options.
  6859  type ERC20OnApproveCallerSession struct {
  6860  	Contract *ERC20OnApproveCaller // Generic contract caller binding to set the session for
  6861  	CallOpts bind.CallOpts         // Call options to use throughout this session
  6862  }
  6863  
  6864  // ERC20OnApproveTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  6865  // with pre-set transact options.
  6866  type ERC20OnApproveTransactorSession struct {
  6867  	Contract     *ERC20OnApproveTransactor // Generic contract transactor binding to set the session for
  6868  	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
  6869  }
  6870  
  6871  // ERC20OnApproveRaw is an auto generated low-level Go binding around an Ethereum contract.
  6872  type ERC20OnApproveRaw struct {
  6873  	Contract *ERC20OnApprove // Generic contract binding to access the raw methods on
  6874  }
  6875  
  6876  // ERC20OnApproveCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  6877  type ERC20OnApproveCallerRaw struct {
  6878  	Contract *ERC20OnApproveCaller // Generic read-only contract binding to access the raw methods on
  6879  }
  6880  
  6881  // ERC20OnApproveTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  6882  type ERC20OnApproveTransactorRaw struct {
  6883  	Contract *ERC20OnApproveTransactor // Generic write-only contract binding to access the raw methods on
  6884  }
  6885  
  6886  // NewERC20OnApprove creates a new instance of ERC20OnApprove, bound to a specific deployed contract.
  6887  func NewERC20OnApprove(address common.Address, backend bind.ContractBackend) (*ERC20OnApprove, error) {
  6888  	contract, err := bindERC20OnApprove(address, backend, backend, backend)
  6889  	if err != nil {
  6890  		return nil, err
  6891  	}
  6892  	return &ERC20OnApprove{ERC20OnApproveCaller: ERC20OnApproveCaller{contract: contract}, ERC20OnApproveTransactor: ERC20OnApproveTransactor{contract: contract}, ERC20OnApproveFilterer: ERC20OnApproveFilterer{contract: contract}}, nil
  6893  }
  6894  
  6895  // NewERC20OnApproveCaller creates a new read-only instance of ERC20OnApprove, bound to a specific deployed contract.
  6896  func NewERC20OnApproveCaller(address common.Address, caller bind.ContractCaller) (*ERC20OnApproveCaller, error) {
  6897  	contract, err := bindERC20OnApprove(address, caller, nil, nil)
  6898  	if err != nil {
  6899  		return nil, err
  6900  	}
  6901  	return &ERC20OnApproveCaller{contract: contract}, nil
  6902  }
  6903  
  6904  // NewERC20OnApproveTransactor creates a new write-only instance of ERC20OnApprove, bound to a specific deployed contract.
  6905  func NewERC20OnApproveTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20OnApproveTransactor, error) {
  6906  	contract, err := bindERC20OnApprove(address, nil, transactor, nil)
  6907  	if err != nil {
  6908  		return nil, err
  6909  	}
  6910  	return &ERC20OnApproveTransactor{contract: contract}, nil
  6911  }
  6912  
  6913  // NewERC20OnApproveFilterer creates a new log filterer instance of ERC20OnApprove, bound to a specific deployed contract.
  6914  func NewERC20OnApproveFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20OnApproveFilterer, error) {
  6915  	contract, err := bindERC20OnApprove(address, nil, nil, filterer)
  6916  	if err != nil {
  6917  		return nil, err
  6918  	}
  6919  	return &ERC20OnApproveFilterer{contract: contract}, nil
  6920  }
  6921  
  6922  // bindERC20OnApprove binds a generic wrapper to an already deployed contract.
  6923  func bindERC20OnApprove(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  6924  	parsed, err := abi.JSON(strings.NewReader(ERC20OnApproveABI))
  6925  	if err != nil {
  6926  		return nil, err
  6927  	}
  6928  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  6929  }
  6930  
  6931  // Call invokes the (constant) contract method with params as input values and
  6932  // sets the output to result. The result type might be a single field for simple
  6933  // returns, a slice of interfaces for anonymous returns and a struct for named
  6934  // returns.
  6935  func (_ERC20OnApprove *ERC20OnApproveRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  6936  	return _ERC20OnApprove.Contract.ERC20OnApproveCaller.contract.Call(opts, result, method, params...)
  6937  }
  6938  
  6939  // Transfer initiates a plain transaction to move funds to the contract, calling
  6940  // its default method if one is available.
  6941  func (_ERC20OnApprove *ERC20OnApproveRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  6942  	return _ERC20OnApprove.Contract.ERC20OnApproveTransactor.contract.Transfer(opts)
  6943  }
  6944  
  6945  // Transact invokes the (paid) contract method with params as input values.
  6946  func (_ERC20OnApprove *ERC20OnApproveRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  6947  	return _ERC20OnApprove.Contract.ERC20OnApproveTransactor.contract.Transact(opts, method, params...)
  6948  }
  6949  
  6950  // Call invokes the (constant) contract method with params as input values and
  6951  // sets the output to result. The result type might be a single field for simple
  6952  // returns, a slice of interfaces for anonymous returns and a struct for named
  6953  // returns.
  6954  func (_ERC20OnApprove *ERC20OnApproveCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  6955  	return _ERC20OnApprove.Contract.contract.Call(opts, result, method, params...)
  6956  }
  6957  
  6958  // Transfer initiates a plain transaction to move funds to the contract, calling
  6959  // its default method if one is available.
  6960  func (_ERC20OnApprove *ERC20OnApproveTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  6961  	return _ERC20OnApprove.Contract.contract.Transfer(opts)
  6962  }
  6963  
  6964  // Transact invokes the (paid) contract method with params as input values.
  6965  func (_ERC20OnApprove *ERC20OnApproveTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  6966  	return _ERC20OnApprove.Contract.contract.Transact(opts, method, params...)
  6967  }
  6968  
  6969  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  6970  //
  6971  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  6972  func (_ERC20OnApprove *ERC20OnApproveCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) {
  6973  	var (
  6974  		ret0 = new([4]byte)
  6975  	)
  6976  	out := ret0
  6977  	err := _ERC20OnApprove.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE")
  6978  	return *ret0, err
  6979  }
  6980  
  6981  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  6982  //
  6983  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  6984  func (_ERC20OnApprove *ERC20OnApproveSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  6985  	return _ERC20OnApprove.Contract.INTERFACEIDONAPPROVE(&_ERC20OnApprove.CallOpts)
  6986  }
  6987  
  6988  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  6989  //
  6990  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  6991  func (_ERC20OnApprove *ERC20OnApproveCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  6992  	return _ERC20OnApprove.Contract.INTERFACEIDONAPPROVE(&_ERC20OnApprove.CallOpts)
  6993  }
  6994  
  6995  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  6996  //
  6997  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  6998  func (_ERC20OnApprove *ERC20OnApproveCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
  6999  	var (
  7000  		ret0 = new(*big.Int)
  7001  	)
  7002  	out := ret0
  7003  	err := _ERC20OnApprove.contract.Call(opts, out, "allowance", owner, spender)
  7004  	return *ret0, err
  7005  }
  7006  
  7007  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  7008  //
  7009  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  7010  func (_ERC20OnApprove *ERC20OnApproveSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  7011  	return _ERC20OnApprove.Contract.Allowance(&_ERC20OnApprove.CallOpts, owner, spender)
  7012  }
  7013  
  7014  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  7015  //
  7016  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  7017  func (_ERC20OnApprove *ERC20OnApproveCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  7018  	return _ERC20OnApprove.Contract.Allowance(&_ERC20OnApprove.CallOpts, owner, spender)
  7019  }
  7020  
  7021  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  7022  //
  7023  // Solidity: function balanceOf(address account) constant returns(uint256)
  7024  func (_ERC20OnApprove *ERC20OnApproveCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  7025  	var (
  7026  		ret0 = new(*big.Int)
  7027  	)
  7028  	out := ret0
  7029  	err := _ERC20OnApprove.contract.Call(opts, out, "balanceOf", account)
  7030  	return *ret0, err
  7031  }
  7032  
  7033  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  7034  //
  7035  // Solidity: function balanceOf(address account) constant returns(uint256)
  7036  func (_ERC20OnApprove *ERC20OnApproveSession) BalanceOf(account common.Address) (*big.Int, error) {
  7037  	return _ERC20OnApprove.Contract.BalanceOf(&_ERC20OnApprove.CallOpts, account)
  7038  }
  7039  
  7040  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  7041  //
  7042  // Solidity: function balanceOf(address account) constant returns(uint256)
  7043  func (_ERC20OnApprove *ERC20OnApproveCallerSession) BalanceOf(account common.Address) (*big.Int, error) {
  7044  	return _ERC20OnApprove.Contract.BalanceOf(&_ERC20OnApprove.CallOpts, account)
  7045  }
  7046  
  7047  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  7048  //
  7049  // Solidity: function totalSupply() constant returns(uint256)
  7050  func (_ERC20OnApprove *ERC20OnApproveCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
  7051  	var (
  7052  		ret0 = new(*big.Int)
  7053  	)
  7054  	out := ret0
  7055  	err := _ERC20OnApprove.contract.Call(opts, out, "totalSupply")
  7056  	return *ret0, err
  7057  }
  7058  
  7059  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  7060  //
  7061  // Solidity: function totalSupply() constant returns(uint256)
  7062  func (_ERC20OnApprove *ERC20OnApproveSession) TotalSupply() (*big.Int, error) {
  7063  	return _ERC20OnApprove.Contract.TotalSupply(&_ERC20OnApprove.CallOpts)
  7064  }
  7065  
  7066  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  7067  //
  7068  // Solidity: function totalSupply() constant returns(uint256)
  7069  func (_ERC20OnApprove *ERC20OnApproveCallerSession) TotalSupply() (*big.Int, error) {
  7070  	return _ERC20OnApprove.Contract.TotalSupply(&_ERC20OnApprove.CallOpts)
  7071  }
  7072  
  7073  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  7074  //
  7075  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  7076  func (_ERC20OnApprove *ERC20OnApproveTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
  7077  	return _ERC20OnApprove.contract.Transact(opts, "approve", spender, amount)
  7078  }
  7079  
  7080  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  7081  //
  7082  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  7083  func (_ERC20OnApprove *ERC20OnApproveSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  7084  	return _ERC20OnApprove.Contract.Approve(&_ERC20OnApprove.TransactOpts, spender, amount)
  7085  }
  7086  
  7087  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  7088  //
  7089  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  7090  func (_ERC20OnApprove *ERC20OnApproveTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  7091  	return _ERC20OnApprove.Contract.Approve(&_ERC20OnApprove.TransactOpts, spender, amount)
  7092  }
  7093  
  7094  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
  7095  //
  7096  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
  7097  func (_ERC20OnApprove *ERC20OnApproveTransactor) ApproveAndCall(opts *bind.TransactOpts, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  7098  	return _ERC20OnApprove.contract.Transact(opts, "approveAndCall", spender, amount, data)
  7099  }
  7100  
  7101  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
  7102  //
  7103  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
  7104  func (_ERC20OnApprove *ERC20OnApproveSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  7105  	return _ERC20OnApprove.Contract.ApproveAndCall(&_ERC20OnApprove.TransactOpts, spender, amount, data)
  7106  }
  7107  
  7108  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
  7109  //
  7110  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
  7111  func (_ERC20OnApprove *ERC20OnApproveTransactorSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  7112  	return _ERC20OnApprove.Contract.ApproveAndCall(&_ERC20OnApprove.TransactOpts, spender, amount, data)
  7113  }
  7114  
  7115  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  7116  //
  7117  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  7118  func (_ERC20OnApprove *ERC20OnApproveTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  7119  	return _ERC20OnApprove.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
  7120  }
  7121  
  7122  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  7123  //
  7124  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  7125  func (_ERC20OnApprove *ERC20OnApproveSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  7126  	return _ERC20OnApprove.Contract.DecreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, subtractedValue)
  7127  }
  7128  
  7129  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
  7130  //
  7131  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
  7132  func (_ERC20OnApprove *ERC20OnApproveTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
  7133  	return _ERC20OnApprove.Contract.DecreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, subtractedValue)
  7134  }
  7135  
  7136  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  7137  //
  7138  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  7139  func (_ERC20OnApprove *ERC20OnApproveTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  7140  	return _ERC20OnApprove.contract.Transact(opts, "increaseAllowance", spender, addedValue)
  7141  }
  7142  
  7143  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  7144  //
  7145  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  7146  func (_ERC20OnApprove *ERC20OnApproveSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  7147  	return _ERC20OnApprove.Contract.IncreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, addedValue)
  7148  }
  7149  
  7150  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
  7151  //
  7152  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
  7153  func (_ERC20OnApprove *ERC20OnApproveTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
  7154  	return _ERC20OnApprove.Contract.IncreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, addedValue)
  7155  }
  7156  
  7157  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  7158  //
  7159  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  7160  func (_ERC20OnApprove *ERC20OnApproveTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7161  	return _ERC20OnApprove.contract.Transact(opts, "transfer", recipient, amount)
  7162  }
  7163  
  7164  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  7165  //
  7166  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  7167  func (_ERC20OnApprove *ERC20OnApproveSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7168  	return _ERC20OnApprove.Contract.Transfer(&_ERC20OnApprove.TransactOpts, recipient, amount)
  7169  }
  7170  
  7171  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  7172  //
  7173  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  7174  func (_ERC20OnApprove *ERC20OnApproveTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7175  	return _ERC20OnApprove.Contract.Transfer(&_ERC20OnApprove.TransactOpts, recipient, amount)
  7176  }
  7177  
  7178  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  7179  //
  7180  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  7181  func (_ERC20OnApprove *ERC20OnApproveTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7182  	return _ERC20OnApprove.contract.Transact(opts, "transferFrom", sender, recipient, amount)
  7183  }
  7184  
  7185  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  7186  //
  7187  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  7188  func (_ERC20OnApprove *ERC20OnApproveSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7189  	return _ERC20OnApprove.Contract.TransferFrom(&_ERC20OnApprove.TransactOpts, sender, recipient, amount)
  7190  }
  7191  
  7192  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  7193  //
  7194  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  7195  func (_ERC20OnApprove *ERC20OnApproveTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7196  	return _ERC20OnApprove.Contract.TransferFrom(&_ERC20OnApprove.TransactOpts, sender, recipient, amount)
  7197  }
  7198  
  7199  // 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.
  7200  type ERC20OnApproveApprovalIterator struct {
  7201  	Event *ERC20OnApproveApproval // Event containing the contract specifics and raw log
  7202  
  7203  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  7204  	event    string              // Event name to use for unpacking event data
  7205  
  7206  	logs chan types.Log        // Log channel receiving the found contract events
  7207  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  7208  	done bool                  // Whether the subscription completed delivering logs
  7209  	fail error                 // Occurred error to stop iteration
  7210  }
  7211  
  7212  // Next advances the iterator to the subsequent event, returning whether there
  7213  // are any more events found. In case of a retrieval or parsing error, false is
  7214  // returned and Error() can be queried for the exact failure.
  7215  func (it *ERC20OnApproveApprovalIterator) Next() bool {
  7216  	// If the iterator failed, stop iterating
  7217  	if it.fail != nil {
  7218  		return false
  7219  	}
  7220  	// If the iterator completed, deliver directly whatever's available
  7221  	if it.done {
  7222  		select {
  7223  		case log := <-it.logs:
  7224  			it.Event = new(ERC20OnApproveApproval)
  7225  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  7226  				it.fail = err
  7227  				return false
  7228  			}
  7229  			it.Event.Raw = log
  7230  			return true
  7231  
  7232  		default:
  7233  			return false
  7234  		}
  7235  	}
  7236  	// Iterator still in progress, wait for either a data or an error event
  7237  	select {
  7238  	case log := <-it.logs:
  7239  		it.Event = new(ERC20OnApproveApproval)
  7240  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  7241  			it.fail = err
  7242  			return false
  7243  		}
  7244  		it.Event.Raw = log
  7245  		return true
  7246  
  7247  	case err := <-it.sub.Err():
  7248  		it.done = true
  7249  		it.fail = err
  7250  		return it.Next()
  7251  	}
  7252  }
  7253  
  7254  // Error returns any retrieval or parsing error occurred during filtering.
  7255  func (it *ERC20OnApproveApprovalIterator) Error() error {
  7256  	return it.fail
  7257  }
  7258  
  7259  // Close terminates the iteration process, releasing any pending underlying
  7260  // resources.
  7261  func (it *ERC20OnApproveApprovalIterator) Close() error {
  7262  	it.sub.Unsubscribe()
  7263  	return nil
  7264  }
  7265  
  7266  // ERC20OnApproveApproval represents a Approval event raised by the ERC20OnApprove contract.
  7267  type ERC20OnApproveApproval struct {
  7268  	Owner   common.Address
  7269  	Spender common.Address
  7270  	Value   *big.Int
  7271  	Raw     types.Log // Blockchain specific contextual infos
  7272  }
  7273  
  7274  // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  7275  //
  7276  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  7277  func (_ERC20OnApprove *ERC20OnApproveFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20OnApproveApprovalIterator, error) {
  7278  
  7279  	var ownerRule []interface{}
  7280  	for _, ownerItem := range owner {
  7281  		ownerRule = append(ownerRule, ownerItem)
  7282  	}
  7283  	var spenderRule []interface{}
  7284  	for _, spenderItem := range spender {
  7285  		spenderRule = append(spenderRule, spenderItem)
  7286  	}
  7287  
  7288  	logs, sub, err := _ERC20OnApprove.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
  7289  	if err != nil {
  7290  		return nil, err
  7291  	}
  7292  	return &ERC20OnApproveApprovalIterator{contract: _ERC20OnApprove.contract, event: "Approval", logs: logs, sub: sub}, nil
  7293  }
  7294  
  7295  // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  7296  //
  7297  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  7298  func (_ERC20OnApprove *ERC20OnApproveFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20OnApproveApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
  7299  
  7300  	var ownerRule []interface{}
  7301  	for _, ownerItem := range owner {
  7302  		ownerRule = append(ownerRule, ownerItem)
  7303  	}
  7304  	var spenderRule []interface{}
  7305  	for _, spenderItem := range spender {
  7306  		spenderRule = append(spenderRule, spenderItem)
  7307  	}
  7308  
  7309  	logs, sub, err := _ERC20OnApprove.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
  7310  	if err != nil {
  7311  		return nil, err
  7312  	}
  7313  	return event.NewSubscription(func(quit <-chan struct{}) error {
  7314  		defer sub.Unsubscribe()
  7315  		for {
  7316  			select {
  7317  			case log := <-logs:
  7318  				// New log arrived, parse the event and forward to the user
  7319  				event := new(ERC20OnApproveApproval)
  7320  				if err := _ERC20OnApprove.contract.UnpackLog(event, "Approval", log); err != nil {
  7321  					return err
  7322  				}
  7323  				event.Raw = log
  7324  
  7325  				select {
  7326  				case sink <- event:
  7327  				case err := <-sub.Err():
  7328  					return err
  7329  				case <-quit:
  7330  					return nil
  7331  				}
  7332  			case err := <-sub.Err():
  7333  				return err
  7334  			case <-quit:
  7335  				return nil
  7336  			}
  7337  		}
  7338  	}), nil
  7339  }
  7340  
  7341  // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  7342  //
  7343  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  7344  func (_ERC20OnApprove *ERC20OnApproveFilterer) ParseApproval(log types.Log) (*ERC20OnApproveApproval, error) {
  7345  	event := new(ERC20OnApproveApproval)
  7346  	if err := _ERC20OnApprove.contract.UnpackLog(event, "Approval", log); err != nil {
  7347  		return nil, err
  7348  	}
  7349  	return event, nil
  7350  }
  7351  
  7352  // 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.
  7353  type ERC20OnApproveTransferIterator struct {
  7354  	Event *ERC20OnApproveTransfer // Event containing the contract specifics and raw log
  7355  
  7356  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  7357  	event    string              // Event name to use for unpacking event data
  7358  
  7359  	logs chan types.Log        // Log channel receiving the found contract events
  7360  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  7361  	done bool                  // Whether the subscription completed delivering logs
  7362  	fail error                 // Occurred error to stop iteration
  7363  }
  7364  
  7365  // Next advances the iterator to the subsequent event, returning whether there
  7366  // are any more events found. In case of a retrieval or parsing error, false is
  7367  // returned and Error() can be queried for the exact failure.
  7368  func (it *ERC20OnApproveTransferIterator) Next() bool {
  7369  	// If the iterator failed, stop iterating
  7370  	if it.fail != nil {
  7371  		return false
  7372  	}
  7373  	// If the iterator completed, deliver directly whatever's available
  7374  	if it.done {
  7375  		select {
  7376  		case log := <-it.logs:
  7377  			it.Event = new(ERC20OnApproveTransfer)
  7378  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  7379  				it.fail = err
  7380  				return false
  7381  			}
  7382  			it.Event.Raw = log
  7383  			return true
  7384  
  7385  		default:
  7386  			return false
  7387  		}
  7388  	}
  7389  	// Iterator still in progress, wait for either a data or an error event
  7390  	select {
  7391  	case log := <-it.logs:
  7392  		it.Event = new(ERC20OnApproveTransfer)
  7393  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  7394  			it.fail = err
  7395  			return false
  7396  		}
  7397  		it.Event.Raw = log
  7398  		return true
  7399  
  7400  	case err := <-it.sub.Err():
  7401  		it.done = true
  7402  		it.fail = err
  7403  		return it.Next()
  7404  	}
  7405  }
  7406  
  7407  // Error returns any retrieval or parsing error occurred during filtering.
  7408  func (it *ERC20OnApproveTransferIterator) Error() error {
  7409  	return it.fail
  7410  }
  7411  
  7412  // Close terminates the iteration process, releasing any pending underlying
  7413  // resources.
  7414  func (it *ERC20OnApproveTransferIterator) Close() error {
  7415  	it.sub.Unsubscribe()
  7416  	return nil
  7417  }
  7418  
  7419  // ERC20OnApproveTransfer represents a Transfer event raised by the ERC20OnApprove contract.
  7420  type ERC20OnApproveTransfer struct {
  7421  	From  common.Address
  7422  	To    common.Address
  7423  	Value *big.Int
  7424  	Raw   types.Log // Blockchain specific contextual infos
  7425  }
  7426  
  7427  // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  7428  //
  7429  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  7430  func (_ERC20OnApprove *ERC20OnApproveFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20OnApproveTransferIterator, error) {
  7431  
  7432  	var fromRule []interface{}
  7433  	for _, fromItem := range from {
  7434  		fromRule = append(fromRule, fromItem)
  7435  	}
  7436  	var toRule []interface{}
  7437  	for _, toItem := range to {
  7438  		toRule = append(toRule, toItem)
  7439  	}
  7440  
  7441  	logs, sub, err := _ERC20OnApprove.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
  7442  	if err != nil {
  7443  		return nil, err
  7444  	}
  7445  	return &ERC20OnApproveTransferIterator{contract: _ERC20OnApprove.contract, event: "Transfer", logs: logs, sub: sub}, nil
  7446  }
  7447  
  7448  // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  7449  //
  7450  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  7451  func (_ERC20OnApprove *ERC20OnApproveFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20OnApproveTransfer, from []common.Address, to []common.Address) (event.Subscription, error) {
  7452  
  7453  	var fromRule []interface{}
  7454  	for _, fromItem := range from {
  7455  		fromRule = append(fromRule, fromItem)
  7456  	}
  7457  	var toRule []interface{}
  7458  	for _, toItem := range to {
  7459  		toRule = append(toRule, toItem)
  7460  	}
  7461  
  7462  	logs, sub, err := _ERC20OnApprove.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
  7463  	if err != nil {
  7464  		return nil, err
  7465  	}
  7466  	return event.NewSubscription(func(quit <-chan struct{}) error {
  7467  		defer sub.Unsubscribe()
  7468  		for {
  7469  			select {
  7470  			case log := <-logs:
  7471  				// New log arrived, parse the event and forward to the user
  7472  				event := new(ERC20OnApproveTransfer)
  7473  				if err := _ERC20OnApprove.contract.UnpackLog(event, "Transfer", log); err != nil {
  7474  					return err
  7475  				}
  7476  				event.Raw = log
  7477  
  7478  				select {
  7479  				case sink <- event:
  7480  				case err := <-sub.Err():
  7481  					return err
  7482  				case <-quit:
  7483  					return nil
  7484  				}
  7485  			case err := <-sub.Err():
  7486  				return err
  7487  			case <-quit:
  7488  				return nil
  7489  			}
  7490  		}
  7491  	}), nil
  7492  }
  7493  
  7494  // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  7495  //
  7496  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  7497  func (_ERC20OnApprove *ERC20OnApproveFilterer) ParseTransfer(log types.Log) (*ERC20OnApproveTransfer, error) {
  7498  	event := new(ERC20OnApproveTransfer)
  7499  	if err := _ERC20OnApprove.contract.UnpackLog(event, "Transfer", log); err != nil {
  7500  		return nil, err
  7501  	}
  7502  	return event, nil
  7503  }
  7504  
  7505  // IERC165ABI is the input ABI used to generate the binding from.
  7506  const IERC165ABI = "[{\"constant\":true,\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"
  7507  
  7508  // IERC165FuncSigs maps the 4-byte function signature to its string representation.
  7509  var IERC165FuncSigs = map[string]string{
  7510  	"01ffc9a7": "supportsInterface(bytes4)",
  7511  }
  7512  
  7513  // IERC165 is an auto generated Go binding around an Ethereum contract.
  7514  type IERC165 struct {
  7515  	IERC165Caller     // Read-only binding to the contract
  7516  	IERC165Transactor // Write-only binding to the contract
  7517  	IERC165Filterer   // Log filterer for contract events
  7518  }
  7519  
  7520  // IERC165Caller is an auto generated read-only Go binding around an Ethereum contract.
  7521  type IERC165Caller struct {
  7522  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  7523  }
  7524  
  7525  // IERC165Transactor is an auto generated write-only Go binding around an Ethereum contract.
  7526  type IERC165Transactor struct {
  7527  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  7528  }
  7529  
  7530  // IERC165Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
  7531  type IERC165Filterer struct {
  7532  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  7533  }
  7534  
  7535  // IERC165Session is an auto generated Go binding around an Ethereum contract,
  7536  // with pre-set call and transact options.
  7537  type IERC165Session struct {
  7538  	Contract     *IERC165          // Generic contract binding to set the session for
  7539  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  7540  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  7541  }
  7542  
  7543  // IERC165CallerSession is an auto generated read-only Go binding around an Ethereum contract,
  7544  // with pre-set call options.
  7545  type IERC165CallerSession struct {
  7546  	Contract *IERC165Caller // Generic contract caller binding to set the session for
  7547  	CallOpts bind.CallOpts  // Call options to use throughout this session
  7548  }
  7549  
  7550  // IERC165TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  7551  // with pre-set transact options.
  7552  type IERC165TransactorSession struct {
  7553  	Contract     *IERC165Transactor // Generic contract transactor binding to set the session for
  7554  	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
  7555  }
  7556  
  7557  // IERC165Raw is an auto generated low-level Go binding around an Ethereum contract.
  7558  type IERC165Raw struct {
  7559  	Contract *IERC165 // Generic contract binding to access the raw methods on
  7560  }
  7561  
  7562  // IERC165CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  7563  type IERC165CallerRaw struct {
  7564  	Contract *IERC165Caller // Generic read-only contract binding to access the raw methods on
  7565  }
  7566  
  7567  // IERC165TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  7568  type IERC165TransactorRaw struct {
  7569  	Contract *IERC165Transactor // Generic write-only contract binding to access the raw methods on
  7570  }
  7571  
  7572  // NewIERC165 creates a new instance of IERC165, bound to a specific deployed contract.
  7573  func NewIERC165(address common.Address, backend bind.ContractBackend) (*IERC165, error) {
  7574  	contract, err := bindIERC165(address, backend, backend, backend)
  7575  	if err != nil {
  7576  		return nil, err
  7577  	}
  7578  	return &IERC165{IERC165Caller: IERC165Caller{contract: contract}, IERC165Transactor: IERC165Transactor{contract: contract}, IERC165Filterer: IERC165Filterer{contract: contract}}, nil
  7579  }
  7580  
  7581  // NewIERC165Caller creates a new read-only instance of IERC165, bound to a specific deployed contract.
  7582  func NewIERC165Caller(address common.Address, caller bind.ContractCaller) (*IERC165Caller, error) {
  7583  	contract, err := bindIERC165(address, caller, nil, nil)
  7584  	if err != nil {
  7585  		return nil, err
  7586  	}
  7587  	return &IERC165Caller{contract: contract}, nil
  7588  }
  7589  
  7590  // NewIERC165Transactor creates a new write-only instance of IERC165, bound to a specific deployed contract.
  7591  func NewIERC165Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC165Transactor, error) {
  7592  	contract, err := bindIERC165(address, nil, transactor, nil)
  7593  	if err != nil {
  7594  		return nil, err
  7595  	}
  7596  	return &IERC165Transactor{contract: contract}, nil
  7597  }
  7598  
  7599  // NewIERC165Filterer creates a new log filterer instance of IERC165, bound to a specific deployed contract.
  7600  func NewIERC165Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC165Filterer, error) {
  7601  	contract, err := bindIERC165(address, nil, nil, filterer)
  7602  	if err != nil {
  7603  		return nil, err
  7604  	}
  7605  	return &IERC165Filterer{contract: contract}, nil
  7606  }
  7607  
  7608  // bindIERC165 binds a generic wrapper to an already deployed contract.
  7609  func bindIERC165(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  7610  	parsed, err := abi.JSON(strings.NewReader(IERC165ABI))
  7611  	if err != nil {
  7612  		return nil, err
  7613  	}
  7614  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  7615  }
  7616  
  7617  // Call invokes the (constant) contract method with params as input values and
  7618  // sets the output to result. The result type might be a single field for simple
  7619  // returns, a slice of interfaces for anonymous returns and a struct for named
  7620  // returns.
  7621  func (_IERC165 *IERC165Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  7622  	return _IERC165.Contract.IERC165Caller.contract.Call(opts, result, method, params...)
  7623  }
  7624  
  7625  // Transfer initiates a plain transaction to move funds to the contract, calling
  7626  // its default method if one is available.
  7627  func (_IERC165 *IERC165Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  7628  	return _IERC165.Contract.IERC165Transactor.contract.Transfer(opts)
  7629  }
  7630  
  7631  // Transact invokes the (paid) contract method with params as input values.
  7632  func (_IERC165 *IERC165Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  7633  	return _IERC165.Contract.IERC165Transactor.contract.Transact(opts, method, params...)
  7634  }
  7635  
  7636  // Call invokes the (constant) contract method with params as input values and
  7637  // sets the output to result. The result type might be a single field for simple
  7638  // returns, a slice of interfaces for anonymous returns and a struct for named
  7639  // returns.
  7640  func (_IERC165 *IERC165CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  7641  	return _IERC165.Contract.contract.Call(opts, result, method, params...)
  7642  }
  7643  
  7644  // Transfer initiates a plain transaction to move funds to the contract, calling
  7645  // its default method if one is available.
  7646  func (_IERC165 *IERC165TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  7647  	return _IERC165.Contract.contract.Transfer(opts)
  7648  }
  7649  
  7650  // Transact invokes the (paid) contract method with params as input values.
  7651  func (_IERC165 *IERC165TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  7652  	return _IERC165.Contract.contract.Transact(opts, method, params...)
  7653  }
  7654  
  7655  // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
  7656  //
  7657  // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool)
  7658  func (_IERC165 *IERC165Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
  7659  	var (
  7660  		ret0 = new(bool)
  7661  	)
  7662  	out := ret0
  7663  	err := _IERC165.contract.Call(opts, out, "supportsInterface", interfaceId)
  7664  	return *ret0, err
  7665  }
  7666  
  7667  // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
  7668  //
  7669  // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool)
  7670  func (_IERC165 *IERC165Session) SupportsInterface(interfaceId [4]byte) (bool, error) {
  7671  	return _IERC165.Contract.SupportsInterface(&_IERC165.CallOpts, interfaceId)
  7672  }
  7673  
  7674  // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
  7675  //
  7676  // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool)
  7677  func (_IERC165 *IERC165CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
  7678  	return _IERC165.Contract.SupportsInterface(&_IERC165.CallOpts, interfaceId)
  7679  }
  7680  
  7681  // IERC20ABI is the input ABI used to generate the binding from.
  7682  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\"}]"
  7683  
  7684  // IERC20FuncSigs maps the 4-byte function signature to its string representation.
  7685  var IERC20FuncSigs = map[string]string{
  7686  	"dd62ed3e": "allowance(address,address)",
  7687  	"095ea7b3": "approve(address,uint256)",
  7688  	"70a08231": "balanceOf(address)",
  7689  	"18160ddd": "totalSupply()",
  7690  	"a9059cbb": "transfer(address,uint256)",
  7691  	"23b872dd": "transferFrom(address,address,uint256)",
  7692  }
  7693  
  7694  // IERC20 is an auto generated Go binding around an Ethereum contract.
  7695  type IERC20 struct {
  7696  	IERC20Caller     // Read-only binding to the contract
  7697  	IERC20Transactor // Write-only binding to the contract
  7698  	IERC20Filterer   // Log filterer for contract events
  7699  }
  7700  
  7701  // IERC20Caller is an auto generated read-only Go binding around an Ethereum contract.
  7702  type IERC20Caller struct {
  7703  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  7704  }
  7705  
  7706  // IERC20Transactor is an auto generated write-only Go binding around an Ethereum contract.
  7707  type IERC20Transactor struct {
  7708  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  7709  }
  7710  
  7711  // IERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
  7712  type IERC20Filterer struct {
  7713  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  7714  }
  7715  
  7716  // IERC20Session is an auto generated Go binding around an Ethereum contract,
  7717  // with pre-set call and transact options.
  7718  type IERC20Session struct {
  7719  	Contract     *IERC20           // Generic contract binding to set the session for
  7720  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  7721  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  7722  }
  7723  
  7724  // IERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract,
  7725  // with pre-set call options.
  7726  type IERC20CallerSession struct {
  7727  	Contract *IERC20Caller // Generic contract caller binding to set the session for
  7728  	CallOpts bind.CallOpts // Call options to use throughout this session
  7729  }
  7730  
  7731  // IERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  7732  // with pre-set transact options.
  7733  type IERC20TransactorSession struct {
  7734  	Contract     *IERC20Transactor // Generic contract transactor binding to set the session for
  7735  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  7736  }
  7737  
  7738  // IERC20Raw is an auto generated low-level Go binding around an Ethereum contract.
  7739  type IERC20Raw struct {
  7740  	Contract *IERC20 // Generic contract binding to access the raw methods on
  7741  }
  7742  
  7743  // IERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  7744  type IERC20CallerRaw struct {
  7745  	Contract *IERC20Caller // Generic read-only contract binding to access the raw methods on
  7746  }
  7747  
  7748  // IERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  7749  type IERC20TransactorRaw struct {
  7750  	Contract *IERC20Transactor // Generic write-only contract binding to access the raw methods on
  7751  }
  7752  
  7753  // NewIERC20 creates a new instance of IERC20, bound to a specific deployed contract.
  7754  func NewIERC20(address common.Address, backend bind.ContractBackend) (*IERC20, error) {
  7755  	contract, err := bindIERC20(address, backend, backend, backend)
  7756  	if err != nil {
  7757  		return nil, err
  7758  	}
  7759  	return &IERC20{IERC20Caller: IERC20Caller{contract: contract}, IERC20Transactor: IERC20Transactor{contract: contract}, IERC20Filterer: IERC20Filterer{contract: contract}}, nil
  7760  }
  7761  
  7762  // NewIERC20Caller creates a new read-only instance of IERC20, bound to a specific deployed contract.
  7763  func NewIERC20Caller(address common.Address, caller bind.ContractCaller) (*IERC20Caller, error) {
  7764  	contract, err := bindIERC20(address, caller, nil, nil)
  7765  	if err != nil {
  7766  		return nil, err
  7767  	}
  7768  	return &IERC20Caller{contract: contract}, nil
  7769  }
  7770  
  7771  // NewIERC20Transactor creates a new write-only instance of IERC20, bound to a specific deployed contract.
  7772  func NewIERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC20Transactor, error) {
  7773  	contract, err := bindIERC20(address, nil, transactor, nil)
  7774  	if err != nil {
  7775  		return nil, err
  7776  	}
  7777  	return &IERC20Transactor{contract: contract}, nil
  7778  }
  7779  
  7780  // NewIERC20Filterer creates a new log filterer instance of IERC20, bound to a specific deployed contract.
  7781  func NewIERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC20Filterer, error) {
  7782  	contract, err := bindIERC20(address, nil, nil, filterer)
  7783  	if err != nil {
  7784  		return nil, err
  7785  	}
  7786  	return &IERC20Filterer{contract: contract}, nil
  7787  }
  7788  
  7789  // bindIERC20 binds a generic wrapper to an already deployed contract.
  7790  func bindIERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  7791  	parsed, err := abi.JSON(strings.NewReader(IERC20ABI))
  7792  	if err != nil {
  7793  		return nil, err
  7794  	}
  7795  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  7796  }
  7797  
  7798  // Call invokes the (constant) contract method with params as input values and
  7799  // sets the output to result. The result type might be a single field for simple
  7800  // returns, a slice of interfaces for anonymous returns and a struct for named
  7801  // returns.
  7802  func (_IERC20 *IERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  7803  	return _IERC20.Contract.IERC20Caller.contract.Call(opts, result, method, params...)
  7804  }
  7805  
  7806  // Transfer initiates a plain transaction to move funds to the contract, calling
  7807  // its default method if one is available.
  7808  func (_IERC20 *IERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  7809  	return _IERC20.Contract.IERC20Transactor.contract.Transfer(opts)
  7810  }
  7811  
  7812  // Transact invokes the (paid) contract method with params as input values.
  7813  func (_IERC20 *IERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  7814  	return _IERC20.Contract.IERC20Transactor.contract.Transact(opts, method, params...)
  7815  }
  7816  
  7817  // Call invokes the (constant) contract method with params as input values and
  7818  // sets the output to result. The result type might be a single field for simple
  7819  // returns, a slice of interfaces for anonymous returns and a struct for named
  7820  // returns.
  7821  func (_IERC20 *IERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  7822  	return _IERC20.Contract.contract.Call(opts, result, method, params...)
  7823  }
  7824  
  7825  // Transfer initiates a plain transaction to move funds to the contract, calling
  7826  // its default method if one is available.
  7827  func (_IERC20 *IERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  7828  	return _IERC20.Contract.contract.Transfer(opts)
  7829  }
  7830  
  7831  // Transact invokes the (paid) contract method with params as input values.
  7832  func (_IERC20 *IERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  7833  	return _IERC20.Contract.contract.Transact(opts, method, params...)
  7834  }
  7835  
  7836  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  7837  //
  7838  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  7839  func (_IERC20 *IERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
  7840  	var (
  7841  		ret0 = new(*big.Int)
  7842  	)
  7843  	out := ret0
  7844  	err := _IERC20.contract.Call(opts, out, "allowance", owner, spender)
  7845  	return *ret0, err
  7846  }
  7847  
  7848  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  7849  //
  7850  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  7851  func (_IERC20 *IERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  7852  	return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender)
  7853  }
  7854  
  7855  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
  7856  //
  7857  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
  7858  func (_IERC20 *IERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
  7859  	return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender)
  7860  }
  7861  
  7862  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  7863  //
  7864  // Solidity: function balanceOf(address account) constant returns(uint256)
  7865  func (_IERC20 *IERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
  7866  	var (
  7867  		ret0 = new(*big.Int)
  7868  	)
  7869  	out := ret0
  7870  	err := _IERC20.contract.Call(opts, out, "balanceOf", account)
  7871  	return *ret0, err
  7872  }
  7873  
  7874  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  7875  //
  7876  // Solidity: function balanceOf(address account) constant returns(uint256)
  7877  func (_IERC20 *IERC20Session) BalanceOf(account common.Address) (*big.Int, error) {
  7878  	return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, account)
  7879  }
  7880  
  7881  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
  7882  //
  7883  // Solidity: function balanceOf(address account) constant returns(uint256)
  7884  func (_IERC20 *IERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) {
  7885  	return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, account)
  7886  }
  7887  
  7888  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  7889  //
  7890  // Solidity: function totalSupply() constant returns(uint256)
  7891  func (_IERC20 *IERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
  7892  	var (
  7893  		ret0 = new(*big.Int)
  7894  	)
  7895  	out := ret0
  7896  	err := _IERC20.contract.Call(opts, out, "totalSupply")
  7897  	return *ret0, err
  7898  }
  7899  
  7900  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  7901  //
  7902  // Solidity: function totalSupply() constant returns(uint256)
  7903  func (_IERC20 *IERC20Session) TotalSupply() (*big.Int, error) {
  7904  	return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts)
  7905  }
  7906  
  7907  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
  7908  //
  7909  // Solidity: function totalSupply() constant returns(uint256)
  7910  func (_IERC20 *IERC20CallerSession) TotalSupply() (*big.Int, error) {
  7911  	return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts)
  7912  }
  7913  
  7914  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  7915  //
  7916  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  7917  func (_IERC20 *IERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
  7918  	return _IERC20.contract.Transact(opts, "approve", spender, amount)
  7919  }
  7920  
  7921  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  7922  //
  7923  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  7924  func (_IERC20 *IERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  7925  	return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, amount)
  7926  }
  7927  
  7928  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
  7929  //
  7930  // Solidity: function approve(address spender, uint256 amount) returns(bool)
  7931  func (_IERC20 *IERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
  7932  	return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, amount)
  7933  }
  7934  
  7935  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  7936  //
  7937  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  7938  func (_IERC20 *IERC20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7939  	return _IERC20.contract.Transact(opts, "transfer", recipient, amount)
  7940  }
  7941  
  7942  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  7943  //
  7944  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  7945  func (_IERC20 *IERC20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7946  	return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, recipient, amount)
  7947  }
  7948  
  7949  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
  7950  //
  7951  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
  7952  func (_IERC20 *IERC20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7953  	return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, recipient, amount)
  7954  }
  7955  
  7956  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  7957  //
  7958  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  7959  func (_IERC20 *IERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7960  	return _IERC20.contract.Transact(opts, "transferFrom", sender, recipient, amount)
  7961  }
  7962  
  7963  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  7964  //
  7965  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  7966  func (_IERC20 *IERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7967  	return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, sender, recipient, amount)
  7968  }
  7969  
  7970  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
  7971  //
  7972  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
  7973  func (_IERC20 *IERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
  7974  	return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, sender, recipient, amount)
  7975  }
  7976  
  7977  // 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.
  7978  type IERC20ApprovalIterator struct {
  7979  	Event *IERC20Approval // Event containing the contract specifics and raw log
  7980  
  7981  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  7982  	event    string              // Event name to use for unpacking event data
  7983  
  7984  	logs chan types.Log        // Log channel receiving the found contract events
  7985  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  7986  	done bool                  // Whether the subscription completed delivering logs
  7987  	fail error                 // Occurred error to stop iteration
  7988  }
  7989  
  7990  // Next advances the iterator to the subsequent event, returning whether there
  7991  // are any more events found. In case of a retrieval or parsing error, false is
  7992  // returned and Error() can be queried for the exact failure.
  7993  func (it *IERC20ApprovalIterator) Next() bool {
  7994  	// If the iterator failed, stop iterating
  7995  	if it.fail != nil {
  7996  		return false
  7997  	}
  7998  	// If the iterator completed, deliver directly whatever's available
  7999  	if it.done {
  8000  		select {
  8001  		case log := <-it.logs:
  8002  			it.Event = new(IERC20Approval)
  8003  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  8004  				it.fail = err
  8005  				return false
  8006  			}
  8007  			it.Event.Raw = log
  8008  			return true
  8009  
  8010  		default:
  8011  			return false
  8012  		}
  8013  	}
  8014  	// Iterator still in progress, wait for either a data or an error event
  8015  	select {
  8016  	case log := <-it.logs:
  8017  		it.Event = new(IERC20Approval)
  8018  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  8019  			it.fail = err
  8020  			return false
  8021  		}
  8022  		it.Event.Raw = log
  8023  		return true
  8024  
  8025  	case err := <-it.sub.Err():
  8026  		it.done = true
  8027  		it.fail = err
  8028  		return it.Next()
  8029  	}
  8030  }
  8031  
  8032  // Error returns any retrieval or parsing error occurred during filtering.
  8033  func (it *IERC20ApprovalIterator) Error() error {
  8034  	return it.fail
  8035  }
  8036  
  8037  // Close terminates the iteration process, releasing any pending underlying
  8038  // resources.
  8039  func (it *IERC20ApprovalIterator) Close() error {
  8040  	it.sub.Unsubscribe()
  8041  	return nil
  8042  }
  8043  
  8044  // IERC20Approval represents a Approval event raised by the IERC20 contract.
  8045  type IERC20Approval struct {
  8046  	Owner   common.Address
  8047  	Spender common.Address
  8048  	Value   *big.Int
  8049  	Raw     types.Log // Blockchain specific contextual infos
  8050  }
  8051  
  8052  // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  8053  //
  8054  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  8055  func (_IERC20 *IERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IERC20ApprovalIterator, error) {
  8056  
  8057  	var ownerRule []interface{}
  8058  	for _, ownerItem := range owner {
  8059  		ownerRule = append(ownerRule, ownerItem)
  8060  	}
  8061  	var spenderRule []interface{}
  8062  	for _, spenderItem := range spender {
  8063  		spenderRule = append(spenderRule, spenderItem)
  8064  	}
  8065  
  8066  	logs, sub, err := _IERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
  8067  	if err != nil {
  8068  		return nil, err
  8069  	}
  8070  	return &IERC20ApprovalIterator{contract: _IERC20.contract, event: "Approval", logs: logs, sub: sub}, nil
  8071  }
  8072  
  8073  // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  8074  //
  8075  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  8076  func (_IERC20 *IERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
  8077  
  8078  	var ownerRule []interface{}
  8079  	for _, ownerItem := range owner {
  8080  		ownerRule = append(ownerRule, ownerItem)
  8081  	}
  8082  	var spenderRule []interface{}
  8083  	for _, spenderItem := range spender {
  8084  		spenderRule = append(spenderRule, spenderItem)
  8085  	}
  8086  
  8087  	logs, sub, err := _IERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
  8088  	if err != nil {
  8089  		return nil, err
  8090  	}
  8091  	return event.NewSubscription(func(quit <-chan struct{}) error {
  8092  		defer sub.Unsubscribe()
  8093  		for {
  8094  			select {
  8095  			case log := <-logs:
  8096  				// New log arrived, parse the event and forward to the user
  8097  				event := new(IERC20Approval)
  8098  				if err := _IERC20.contract.UnpackLog(event, "Approval", log); err != nil {
  8099  					return err
  8100  				}
  8101  				event.Raw = log
  8102  
  8103  				select {
  8104  				case sink <- event:
  8105  				case err := <-sub.Err():
  8106  					return err
  8107  				case <-quit:
  8108  					return nil
  8109  				}
  8110  			case err := <-sub.Err():
  8111  				return err
  8112  			case <-quit:
  8113  				return nil
  8114  			}
  8115  		}
  8116  	}), nil
  8117  }
  8118  
  8119  // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
  8120  //
  8121  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
  8122  func (_IERC20 *IERC20Filterer) ParseApproval(log types.Log) (*IERC20Approval, error) {
  8123  	event := new(IERC20Approval)
  8124  	if err := _IERC20.contract.UnpackLog(event, "Approval", log); err != nil {
  8125  		return nil, err
  8126  	}
  8127  	return event, nil
  8128  }
  8129  
  8130  // 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.
  8131  type IERC20TransferIterator struct {
  8132  	Event *IERC20Transfer // Event containing the contract specifics and raw log
  8133  
  8134  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  8135  	event    string              // Event name to use for unpacking event data
  8136  
  8137  	logs chan types.Log        // Log channel receiving the found contract events
  8138  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  8139  	done bool                  // Whether the subscription completed delivering logs
  8140  	fail error                 // Occurred error to stop iteration
  8141  }
  8142  
  8143  // Next advances the iterator to the subsequent event, returning whether there
  8144  // are any more events found. In case of a retrieval or parsing error, false is
  8145  // returned and Error() can be queried for the exact failure.
  8146  func (it *IERC20TransferIterator) Next() bool {
  8147  	// If the iterator failed, stop iterating
  8148  	if it.fail != nil {
  8149  		return false
  8150  	}
  8151  	// If the iterator completed, deliver directly whatever's available
  8152  	if it.done {
  8153  		select {
  8154  		case log := <-it.logs:
  8155  			it.Event = new(IERC20Transfer)
  8156  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  8157  				it.fail = err
  8158  				return false
  8159  			}
  8160  			it.Event.Raw = log
  8161  			return true
  8162  
  8163  		default:
  8164  			return false
  8165  		}
  8166  	}
  8167  	// Iterator still in progress, wait for either a data or an error event
  8168  	select {
  8169  	case log := <-it.logs:
  8170  		it.Event = new(IERC20Transfer)
  8171  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  8172  			it.fail = err
  8173  			return false
  8174  		}
  8175  		it.Event.Raw = log
  8176  		return true
  8177  
  8178  	case err := <-it.sub.Err():
  8179  		it.done = true
  8180  		it.fail = err
  8181  		return it.Next()
  8182  	}
  8183  }
  8184  
  8185  // Error returns any retrieval or parsing error occurred during filtering.
  8186  func (it *IERC20TransferIterator) Error() error {
  8187  	return it.fail
  8188  }
  8189  
  8190  // Close terminates the iteration process, releasing any pending underlying
  8191  // resources.
  8192  func (it *IERC20TransferIterator) Close() error {
  8193  	it.sub.Unsubscribe()
  8194  	return nil
  8195  }
  8196  
  8197  // IERC20Transfer represents a Transfer event raised by the IERC20 contract.
  8198  type IERC20Transfer struct {
  8199  	From  common.Address
  8200  	To    common.Address
  8201  	Value *big.Int
  8202  	Raw   types.Log // Blockchain specific contextual infos
  8203  }
  8204  
  8205  // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  8206  //
  8207  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  8208  func (_IERC20 *IERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IERC20TransferIterator, error) {
  8209  
  8210  	var fromRule []interface{}
  8211  	for _, fromItem := range from {
  8212  		fromRule = append(fromRule, fromItem)
  8213  	}
  8214  	var toRule []interface{}
  8215  	for _, toItem := range to {
  8216  		toRule = append(toRule, toItem)
  8217  	}
  8218  
  8219  	logs, sub, err := _IERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
  8220  	if err != nil {
  8221  		return nil, err
  8222  	}
  8223  	return &IERC20TransferIterator{contract: _IERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil
  8224  }
  8225  
  8226  // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  8227  //
  8228  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  8229  func (_IERC20 *IERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) {
  8230  
  8231  	var fromRule []interface{}
  8232  	for _, fromItem := range from {
  8233  		fromRule = append(fromRule, fromItem)
  8234  	}
  8235  	var toRule []interface{}
  8236  	for _, toItem := range to {
  8237  		toRule = append(toRule, toItem)
  8238  	}
  8239  
  8240  	logs, sub, err := _IERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
  8241  	if err != nil {
  8242  		return nil, err
  8243  	}
  8244  	return event.NewSubscription(func(quit <-chan struct{}) error {
  8245  		defer sub.Unsubscribe()
  8246  		for {
  8247  			select {
  8248  			case log := <-logs:
  8249  				// New log arrived, parse the event and forward to the user
  8250  				event := new(IERC20Transfer)
  8251  				if err := _IERC20.contract.UnpackLog(event, "Transfer", log); err != nil {
  8252  					return err
  8253  				}
  8254  				event.Raw = log
  8255  
  8256  				select {
  8257  				case sink <- event:
  8258  				case err := <-sub.Err():
  8259  					return err
  8260  				case <-quit:
  8261  					return nil
  8262  				}
  8263  			case err := <-sub.Err():
  8264  				return err
  8265  			case <-quit:
  8266  				return nil
  8267  			}
  8268  		}
  8269  	}), nil
  8270  }
  8271  
  8272  // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
  8273  //
  8274  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
  8275  func (_IERC20 *IERC20Filterer) ParseTransfer(log types.Log) (*IERC20Transfer, error) {
  8276  	event := new(IERC20Transfer)
  8277  	if err := _IERC20.contract.UnpackLog(event, "Transfer", log); err != nil {
  8278  		return nil, err
  8279  	}
  8280  	return event, nil
  8281  }
  8282  
  8283  // MinterRoleABI is the input ABI used to generate the binding from.
  8284  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\"}]"
  8285  
  8286  // MinterRoleFuncSigs maps the 4-byte function signature to its string representation.
  8287  var MinterRoleFuncSigs = map[string]string{
  8288  	"983b2d56": "addMinter(address)",
  8289  	"aa271e1a": "isMinter(address)",
  8290  	"98650275": "renounceMinter()",
  8291  }
  8292  
  8293  // MinterRole is an auto generated Go binding around an Ethereum contract.
  8294  type MinterRole struct {
  8295  	MinterRoleCaller     // Read-only binding to the contract
  8296  	MinterRoleTransactor // Write-only binding to the contract
  8297  	MinterRoleFilterer   // Log filterer for contract events
  8298  }
  8299  
  8300  // MinterRoleCaller is an auto generated read-only Go binding around an Ethereum contract.
  8301  type MinterRoleCaller struct {
  8302  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  8303  }
  8304  
  8305  // MinterRoleTransactor is an auto generated write-only Go binding around an Ethereum contract.
  8306  type MinterRoleTransactor struct {
  8307  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  8308  }
  8309  
  8310  // MinterRoleFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  8311  type MinterRoleFilterer struct {
  8312  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  8313  }
  8314  
  8315  // MinterRoleSession is an auto generated Go binding around an Ethereum contract,
  8316  // with pre-set call and transact options.
  8317  type MinterRoleSession struct {
  8318  	Contract     *MinterRole       // Generic contract binding to set the session for
  8319  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  8320  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  8321  }
  8322  
  8323  // MinterRoleCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  8324  // with pre-set call options.
  8325  type MinterRoleCallerSession struct {
  8326  	Contract *MinterRoleCaller // Generic contract caller binding to set the session for
  8327  	CallOpts bind.CallOpts     // Call options to use throughout this session
  8328  }
  8329  
  8330  // MinterRoleTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  8331  // with pre-set transact options.
  8332  type MinterRoleTransactorSession struct {
  8333  	Contract     *MinterRoleTransactor // Generic contract transactor binding to set the session for
  8334  	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
  8335  }
  8336  
  8337  // MinterRoleRaw is an auto generated low-level Go binding around an Ethereum contract.
  8338  type MinterRoleRaw struct {
  8339  	Contract *MinterRole // Generic contract binding to access the raw methods on
  8340  }
  8341  
  8342  // MinterRoleCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  8343  type MinterRoleCallerRaw struct {
  8344  	Contract *MinterRoleCaller // Generic read-only contract binding to access the raw methods on
  8345  }
  8346  
  8347  // MinterRoleTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  8348  type MinterRoleTransactorRaw struct {
  8349  	Contract *MinterRoleTransactor // Generic write-only contract binding to access the raw methods on
  8350  }
  8351  
  8352  // NewMinterRole creates a new instance of MinterRole, bound to a specific deployed contract.
  8353  func NewMinterRole(address common.Address, backend bind.ContractBackend) (*MinterRole, error) {
  8354  	contract, err := bindMinterRole(address, backend, backend, backend)
  8355  	if err != nil {
  8356  		return nil, err
  8357  	}
  8358  	return &MinterRole{MinterRoleCaller: MinterRoleCaller{contract: contract}, MinterRoleTransactor: MinterRoleTransactor{contract: contract}, MinterRoleFilterer: MinterRoleFilterer{contract: contract}}, nil
  8359  }
  8360  
  8361  // NewMinterRoleCaller creates a new read-only instance of MinterRole, bound to a specific deployed contract.
  8362  func NewMinterRoleCaller(address common.Address, caller bind.ContractCaller) (*MinterRoleCaller, error) {
  8363  	contract, err := bindMinterRole(address, caller, nil, nil)
  8364  	if err != nil {
  8365  		return nil, err
  8366  	}
  8367  	return &MinterRoleCaller{contract: contract}, nil
  8368  }
  8369  
  8370  // NewMinterRoleTransactor creates a new write-only instance of MinterRole, bound to a specific deployed contract.
  8371  func NewMinterRoleTransactor(address common.Address, transactor bind.ContractTransactor) (*MinterRoleTransactor, error) {
  8372  	contract, err := bindMinterRole(address, nil, transactor, nil)
  8373  	if err != nil {
  8374  		return nil, err
  8375  	}
  8376  	return &MinterRoleTransactor{contract: contract}, nil
  8377  }
  8378  
  8379  // NewMinterRoleFilterer creates a new log filterer instance of MinterRole, bound to a specific deployed contract.
  8380  func NewMinterRoleFilterer(address common.Address, filterer bind.ContractFilterer) (*MinterRoleFilterer, error) {
  8381  	contract, err := bindMinterRole(address, nil, nil, filterer)
  8382  	if err != nil {
  8383  		return nil, err
  8384  	}
  8385  	return &MinterRoleFilterer{contract: contract}, nil
  8386  }
  8387  
  8388  // bindMinterRole binds a generic wrapper to an already deployed contract.
  8389  func bindMinterRole(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  8390  	parsed, err := abi.JSON(strings.NewReader(MinterRoleABI))
  8391  	if err != nil {
  8392  		return nil, err
  8393  	}
  8394  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  8395  }
  8396  
  8397  // Call invokes the (constant) contract method with params as input values and
  8398  // sets the output to result. The result type might be a single field for simple
  8399  // returns, a slice of interfaces for anonymous returns and a struct for named
  8400  // returns.
  8401  func (_MinterRole *MinterRoleRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  8402  	return _MinterRole.Contract.MinterRoleCaller.contract.Call(opts, result, method, params...)
  8403  }
  8404  
  8405  // Transfer initiates a plain transaction to move funds to the contract, calling
  8406  // its default method if one is available.
  8407  func (_MinterRole *MinterRoleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  8408  	return _MinterRole.Contract.MinterRoleTransactor.contract.Transfer(opts)
  8409  }
  8410  
  8411  // Transact invokes the (paid) contract method with params as input values.
  8412  func (_MinterRole *MinterRoleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  8413  	return _MinterRole.Contract.MinterRoleTransactor.contract.Transact(opts, method, params...)
  8414  }
  8415  
  8416  // Call invokes the (constant) contract method with params as input values and
  8417  // sets the output to result. The result type might be a single field for simple
  8418  // returns, a slice of interfaces for anonymous returns and a struct for named
  8419  // returns.
  8420  func (_MinterRole *MinterRoleCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  8421  	return _MinterRole.Contract.contract.Call(opts, result, method, params...)
  8422  }
  8423  
  8424  // Transfer initiates a plain transaction to move funds to the contract, calling
  8425  // its default method if one is available.
  8426  func (_MinterRole *MinterRoleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  8427  	return _MinterRole.Contract.contract.Transfer(opts)
  8428  }
  8429  
  8430  // Transact invokes the (paid) contract method with params as input values.
  8431  func (_MinterRole *MinterRoleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  8432  	return _MinterRole.Contract.contract.Transact(opts, method, params...)
  8433  }
  8434  
  8435  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
  8436  //
  8437  // Solidity: function isMinter(address account) constant returns(bool)
  8438  func (_MinterRole *MinterRoleCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) {
  8439  	var (
  8440  		ret0 = new(bool)
  8441  	)
  8442  	out := ret0
  8443  	err := _MinterRole.contract.Call(opts, out, "isMinter", account)
  8444  	return *ret0, err
  8445  }
  8446  
  8447  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
  8448  //
  8449  // Solidity: function isMinter(address account) constant returns(bool)
  8450  func (_MinterRole *MinterRoleSession) IsMinter(account common.Address) (bool, error) {
  8451  	return _MinterRole.Contract.IsMinter(&_MinterRole.CallOpts, account)
  8452  }
  8453  
  8454  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
  8455  //
  8456  // Solidity: function isMinter(address account) constant returns(bool)
  8457  func (_MinterRole *MinterRoleCallerSession) IsMinter(account common.Address) (bool, error) {
  8458  	return _MinterRole.Contract.IsMinter(&_MinterRole.CallOpts, account)
  8459  }
  8460  
  8461  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
  8462  //
  8463  // Solidity: function addMinter(address account) returns()
  8464  func (_MinterRole *MinterRoleTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
  8465  	return _MinterRole.contract.Transact(opts, "addMinter", account)
  8466  }
  8467  
  8468  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
  8469  //
  8470  // Solidity: function addMinter(address account) returns()
  8471  func (_MinterRole *MinterRoleSession) AddMinter(account common.Address) (*types.Transaction, error) {
  8472  	return _MinterRole.Contract.AddMinter(&_MinterRole.TransactOpts, account)
  8473  }
  8474  
  8475  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
  8476  //
  8477  // Solidity: function addMinter(address account) returns()
  8478  func (_MinterRole *MinterRoleTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) {
  8479  	return _MinterRole.Contract.AddMinter(&_MinterRole.TransactOpts, account)
  8480  }
  8481  
  8482  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  8483  //
  8484  // Solidity: function renounceMinter() returns()
  8485  func (_MinterRole *MinterRoleTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) {
  8486  	return _MinterRole.contract.Transact(opts, "renounceMinter")
  8487  }
  8488  
  8489  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  8490  //
  8491  // Solidity: function renounceMinter() returns()
  8492  func (_MinterRole *MinterRoleSession) RenounceMinter() (*types.Transaction, error) {
  8493  	return _MinterRole.Contract.RenounceMinter(&_MinterRole.TransactOpts)
  8494  }
  8495  
  8496  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  8497  //
  8498  // Solidity: function renounceMinter() returns()
  8499  func (_MinterRole *MinterRoleTransactorSession) RenounceMinter() (*types.Transaction, error) {
  8500  	return _MinterRole.Contract.RenounceMinter(&_MinterRole.TransactOpts)
  8501  }
  8502  
  8503  // 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.
  8504  type MinterRoleMinterAddedIterator struct {
  8505  	Event *MinterRoleMinterAdded // Event containing the contract specifics and raw log
  8506  
  8507  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  8508  	event    string              // Event name to use for unpacking event data
  8509  
  8510  	logs chan types.Log        // Log channel receiving the found contract events
  8511  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  8512  	done bool                  // Whether the subscription completed delivering logs
  8513  	fail error                 // Occurred error to stop iteration
  8514  }
  8515  
  8516  // Next advances the iterator to the subsequent event, returning whether there
  8517  // are any more events found. In case of a retrieval or parsing error, false is
  8518  // returned and Error() can be queried for the exact failure.
  8519  func (it *MinterRoleMinterAddedIterator) Next() bool {
  8520  	// If the iterator failed, stop iterating
  8521  	if it.fail != nil {
  8522  		return false
  8523  	}
  8524  	// If the iterator completed, deliver directly whatever's available
  8525  	if it.done {
  8526  		select {
  8527  		case log := <-it.logs:
  8528  			it.Event = new(MinterRoleMinterAdded)
  8529  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  8530  				it.fail = err
  8531  				return false
  8532  			}
  8533  			it.Event.Raw = log
  8534  			return true
  8535  
  8536  		default:
  8537  			return false
  8538  		}
  8539  	}
  8540  	// Iterator still in progress, wait for either a data or an error event
  8541  	select {
  8542  	case log := <-it.logs:
  8543  		it.Event = new(MinterRoleMinterAdded)
  8544  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  8545  			it.fail = err
  8546  			return false
  8547  		}
  8548  		it.Event.Raw = log
  8549  		return true
  8550  
  8551  	case err := <-it.sub.Err():
  8552  		it.done = true
  8553  		it.fail = err
  8554  		return it.Next()
  8555  	}
  8556  }
  8557  
  8558  // Error returns any retrieval or parsing error occurred during filtering.
  8559  func (it *MinterRoleMinterAddedIterator) Error() error {
  8560  	return it.fail
  8561  }
  8562  
  8563  // Close terminates the iteration process, releasing any pending underlying
  8564  // resources.
  8565  func (it *MinterRoleMinterAddedIterator) Close() error {
  8566  	it.sub.Unsubscribe()
  8567  	return nil
  8568  }
  8569  
  8570  // MinterRoleMinterAdded represents a MinterAdded event raised by the MinterRole contract.
  8571  type MinterRoleMinterAdded struct {
  8572  	Account common.Address
  8573  	Raw     types.Log // Blockchain specific contextual infos
  8574  }
  8575  
  8576  // FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
  8577  //
  8578  // Solidity: event MinterAdded(address indexed account)
  8579  func (_MinterRole *MinterRoleFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*MinterRoleMinterAddedIterator, error) {
  8580  
  8581  	var accountRule []interface{}
  8582  	for _, accountItem := range account {
  8583  		accountRule = append(accountRule, accountItem)
  8584  	}
  8585  
  8586  	logs, sub, err := _MinterRole.contract.FilterLogs(opts, "MinterAdded", accountRule)
  8587  	if err != nil {
  8588  		return nil, err
  8589  	}
  8590  	return &MinterRoleMinterAddedIterator{contract: _MinterRole.contract, event: "MinterAdded", logs: logs, sub: sub}, nil
  8591  }
  8592  
  8593  // WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
  8594  //
  8595  // Solidity: event MinterAdded(address indexed account)
  8596  func (_MinterRole *MinterRoleFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *MinterRoleMinterAdded, account []common.Address) (event.Subscription, error) {
  8597  
  8598  	var accountRule []interface{}
  8599  	for _, accountItem := range account {
  8600  		accountRule = append(accountRule, accountItem)
  8601  	}
  8602  
  8603  	logs, sub, err := _MinterRole.contract.WatchLogs(opts, "MinterAdded", accountRule)
  8604  	if err != nil {
  8605  		return nil, err
  8606  	}
  8607  	return event.NewSubscription(func(quit <-chan struct{}) error {
  8608  		defer sub.Unsubscribe()
  8609  		for {
  8610  			select {
  8611  			case log := <-logs:
  8612  				// New log arrived, parse the event and forward to the user
  8613  				event := new(MinterRoleMinterAdded)
  8614  				if err := _MinterRole.contract.UnpackLog(event, "MinterAdded", log); err != nil {
  8615  					return err
  8616  				}
  8617  				event.Raw = log
  8618  
  8619  				select {
  8620  				case sink <- event:
  8621  				case err := <-sub.Err():
  8622  					return err
  8623  				case <-quit:
  8624  					return nil
  8625  				}
  8626  			case err := <-sub.Err():
  8627  				return err
  8628  			case <-quit:
  8629  				return nil
  8630  			}
  8631  		}
  8632  	}), nil
  8633  }
  8634  
  8635  // ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
  8636  //
  8637  // Solidity: event MinterAdded(address indexed account)
  8638  func (_MinterRole *MinterRoleFilterer) ParseMinterAdded(log types.Log) (*MinterRoleMinterAdded, error) {
  8639  	event := new(MinterRoleMinterAdded)
  8640  	if err := _MinterRole.contract.UnpackLog(event, "MinterAdded", log); err != nil {
  8641  		return nil, err
  8642  	}
  8643  	return event, nil
  8644  }
  8645  
  8646  // 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.
  8647  type MinterRoleMinterRemovedIterator struct {
  8648  	Event *MinterRoleMinterRemoved // Event containing the contract specifics and raw log
  8649  
  8650  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  8651  	event    string              // Event name to use for unpacking event data
  8652  
  8653  	logs chan types.Log        // Log channel receiving the found contract events
  8654  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  8655  	done bool                  // Whether the subscription completed delivering logs
  8656  	fail error                 // Occurred error to stop iteration
  8657  }
  8658  
  8659  // Next advances the iterator to the subsequent event, returning whether there
  8660  // are any more events found. In case of a retrieval or parsing error, false is
  8661  // returned and Error() can be queried for the exact failure.
  8662  func (it *MinterRoleMinterRemovedIterator) Next() bool {
  8663  	// If the iterator failed, stop iterating
  8664  	if it.fail != nil {
  8665  		return false
  8666  	}
  8667  	// If the iterator completed, deliver directly whatever's available
  8668  	if it.done {
  8669  		select {
  8670  		case log := <-it.logs:
  8671  			it.Event = new(MinterRoleMinterRemoved)
  8672  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  8673  				it.fail = err
  8674  				return false
  8675  			}
  8676  			it.Event.Raw = log
  8677  			return true
  8678  
  8679  		default:
  8680  			return false
  8681  		}
  8682  	}
  8683  	// Iterator still in progress, wait for either a data or an error event
  8684  	select {
  8685  	case log := <-it.logs:
  8686  		it.Event = new(MinterRoleMinterRemoved)
  8687  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  8688  			it.fail = err
  8689  			return false
  8690  		}
  8691  		it.Event.Raw = log
  8692  		return true
  8693  
  8694  	case err := <-it.sub.Err():
  8695  		it.done = true
  8696  		it.fail = err
  8697  		return it.Next()
  8698  	}
  8699  }
  8700  
  8701  // Error returns any retrieval or parsing error occurred during filtering.
  8702  func (it *MinterRoleMinterRemovedIterator) Error() error {
  8703  	return it.fail
  8704  }
  8705  
  8706  // Close terminates the iteration process, releasing any pending underlying
  8707  // resources.
  8708  func (it *MinterRoleMinterRemovedIterator) Close() error {
  8709  	it.sub.Unsubscribe()
  8710  	return nil
  8711  }
  8712  
  8713  // MinterRoleMinterRemoved represents a MinterRemoved event raised by the MinterRole contract.
  8714  type MinterRoleMinterRemoved struct {
  8715  	Account common.Address
  8716  	Raw     types.Log // Blockchain specific contextual infos
  8717  }
  8718  
  8719  // FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
  8720  //
  8721  // Solidity: event MinterRemoved(address indexed account)
  8722  func (_MinterRole *MinterRoleFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*MinterRoleMinterRemovedIterator, error) {
  8723  
  8724  	var accountRule []interface{}
  8725  	for _, accountItem := range account {
  8726  		accountRule = append(accountRule, accountItem)
  8727  	}
  8728  
  8729  	logs, sub, err := _MinterRole.contract.FilterLogs(opts, "MinterRemoved", accountRule)
  8730  	if err != nil {
  8731  		return nil, err
  8732  	}
  8733  	return &MinterRoleMinterRemovedIterator{contract: _MinterRole.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil
  8734  }
  8735  
  8736  // WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
  8737  //
  8738  // Solidity: event MinterRemoved(address indexed account)
  8739  func (_MinterRole *MinterRoleFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *MinterRoleMinterRemoved, account []common.Address) (event.Subscription, error) {
  8740  
  8741  	var accountRule []interface{}
  8742  	for _, accountItem := range account {
  8743  		accountRule = append(accountRule, accountItem)
  8744  	}
  8745  
  8746  	logs, sub, err := _MinterRole.contract.WatchLogs(opts, "MinterRemoved", accountRule)
  8747  	if err != nil {
  8748  		return nil, err
  8749  	}
  8750  	return event.NewSubscription(func(quit <-chan struct{}) error {
  8751  		defer sub.Unsubscribe()
  8752  		for {
  8753  			select {
  8754  			case log := <-logs:
  8755  				// New log arrived, parse the event and forward to the user
  8756  				event := new(MinterRoleMinterRemoved)
  8757  				if err := _MinterRole.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
  8758  					return err
  8759  				}
  8760  				event.Raw = log
  8761  
  8762  				select {
  8763  				case sink <- event:
  8764  				case err := <-sub.Err():
  8765  					return err
  8766  				case <-quit:
  8767  					return nil
  8768  				}
  8769  			case err := <-sub.Err():
  8770  				return err
  8771  			case <-quit:
  8772  				return nil
  8773  			}
  8774  		}
  8775  	}), nil
  8776  }
  8777  
  8778  // ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
  8779  //
  8780  // Solidity: event MinterRemoved(address indexed account)
  8781  func (_MinterRole *MinterRoleFilterer) ParseMinterRemoved(log types.Log) (*MinterRoleMinterRemoved, error) {
  8782  	event := new(MinterRoleMinterRemoved)
  8783  	if err := _MinterRole.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
  8784  		return nil, err
  8785  	}
  8786  	return event, nil
  8787  }
  8788  
  8789  // MinterRoleRenounceTargetABI is the input ABI used to generate the binding from.
  8790  const MinterRoleRenounceTargetABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
  8791  
  8792  // MinterRoleRenounceTargetFuncSigs maps the 4-byte function signature to its string representation.
  8793  var MinterRoleRenounceTargetFuncSigs = map[string]string{
  8794  	"98650275": "renounceMinter()",
  8795  }
  8796  
  8797  // MinterRoleRenounceTarget is an auto generated Go binding around an Ethereum contract.
  8798  type MinterRoleRenounceTarget struct {
  8799  	MinterRoleRenounceTargetCaller     // Read-only binding to the contract
  8800  	MinterRoleRenounceTargetTransactor // Write-only binding to the contract
  8801  	MinterRoleRenounceTargetFilterer   // Log filterer for contract events
  8802  }
  8803  
  8804  // MinterRoleRenounceTargetCaller is an auto generated read-only Go binding around an Ethereum contract.
  8805  type MinterRoleRenounceTargetCaller struct {
  8806  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  8807  }
  8808  
  8809  // MinterRoleRenounceTargetTransactor is an auto generated write-only Go binding around an Ethereum contract.
  8810  type MinterRoleRenounceTargetTransactor struct {
  8811  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  8812  }
  8813  
  8814  // MinterRoleRenounceTargetFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  8815  type MinterRoleRenounceTargetFilterer struct {
  8816  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  8817  }
  8818  
  8819  // MinterRoleRenounceTargetSession is an auto generated Go binding around an Ethereum contract,
  8820  // with pre-set call and transact options.
  8821  type MinterRoleRenounceTargetSession struct {
  8822  	Contract     *MinterRoleRenounceTarget // Generic contract binding to set the session for
  8823  	CallOpts     bind.CallOpts             // Call options to use throughout this session
  8824  	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
  8825  }
  8826  
  8827  // MinterRoleRenounceTargetCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  8828  // with pre-set call options.
  8829  type MinterRoleRenounceTargetCallerSession struct {
  8830  	Contract *MinterRoleRenounceTargetCaller // Generic contract caller binding to set the session for
  8831  	CallOpts bind.CallOpts                   // Call options to use throughout this session
  8832  }
  8833  
  8834  // MinterRoleRenounceTargetTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  8835  // with pre-set transact options.
  8836  type MinterRoleRenounceTargetTransactorSession struct {
  8837  	Contract     *MinterRoleRenounceTargetTransactor // Generic contract transactor binding to set the session for
  8838  	TransactOpts bind.TransactOpts                   // Transaction auth options to use throughout this session
  8839  }
  8840  
  8841  // MinterRoleRenounceTargetRaw is an auto generated low-level Go binding around an Ethereum contract.
  8842  type MinterRoleRenounceTargetRaw struct {
  8843  	Contract *MinterRoleRenounceTarget // Generic contract binding to access the raw methods on
  8844  }
  8845  
  8846  // MinterRoleRenounceTargetCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  8847  type MinterRoleRenounceTargetCallerRaw struct {
  8848  	Contract *MinterRoleRenounceTargetCaller // Generic read-only contract binding to access the raw methods on
  8849  }
  8850  
  8851  // MinterRoleRenounceTargetTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  8852  type MinterRoleRenounceTargetTransactorRaw struct {
  8853  	Contract *MinterRoleRenounceTargetTransactor // Generic write-only contract binding to access the raw methods on
  8854  }
  8855  
  8856  // NewMinterRoleRenounceTarget creates a new instance of MinterRoleRenounceTarget, bound to a specific deployed contract.
  8857  func NewMinterRoleRenounceTarget(address common.Address, backend bind.ContractBackend) (*MinterRoleRenounceTarget, error) {
  8858  	contract, err := bindMinterRoleRenounceTarget(address, backend, backend, backend)
  8859  	if err != nil {
  8860  		return nil, err
  8861  	}
  8862  	return &MinterRoleRenounceTarget{MinterRoleRenounceTargetCaller: MinterRoleRenounceTargetCaller{contract: contract}, MinterRoleRenounceTargetTransactor: MinterRoleRenounceTargetTransactor{contract: contract}, MinterRoleRenounceTargetFilterer: MinterRoleRenounceTargetFilterer{contract: contract}}, nil
  8863  }
  8864  
  8865  // NewMinterRoleRenounceTargetCaller creates a new read-only instance of MinterRoleRenounceTarget, bound to a specific deployed contract.
  8866  func NewMinterRoleRenounceTargetCaller(address common.Address, caller bind.ContractCaller) (*MinterRoleRenounceTargetCaller, error) {
  8867  	contract, err := bindMinterRoleRenounceTarget(address, caller, nil, nil)
  8868  	if err != nil {
  8869  		return nil, err
  8870  	}
  8871  	return &MinterRoleRenounceTargetCaller{contract: contract}, nil
  8872  }
  8873  
  8874  // NewMinterRoleRenounceTargetTransactor creates a new write-only instance of MinterRoleRenounceTarget, bound to a specific deployed contract.
  8875  func NewMinterRoleRenounceTargetTransactor(address common.Address, transactor bind.ContractTransactor) (*MinterRoleRenounceTargetTransactor, error) {
  8876  	contract, err := bindMinterRoleRenounceTarget(address, nil, transactor, nil)
  8877  	if err != nil {
  8878  		return nil, err
  8879  	}
  8880  	return &MinterRoleRenounceTargetTransactor{contract: contract}, nil
  8881  }
  8882  
  8883  // NewMinterRoleRenounceTargetFilterer creates a new log filterer instance of MinterRoleRenounceTarget, bound to a specific deployed contract.
  8884  func NewMinterRoleRenounceTargetFilterer(address common.Address, filterer bind.ContractFilterer) (*MinterRoleRenounceTargetFilterer, error) {
  8885  	contract, err := bindMinterRoleRenounceTarget(address, nil, nil, filterer)
  8886  	if err != nil {
  8887  		return nil, err
  8888  	}
  8889  	return &MinterRoleRenounceTargetFilterer{contract: contract}, nil
  8890  }
  8891  
  8892  // bindMinterRoleRenounceTarget binds a generic wrapper to an already deployed contract.
  8893  func bindMinterRoleRenounceTarget(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  8894  	parsed, err := abi.JSON(strings.NewReader(MinterRoleRenounceTargetABI))
  8895  	if err != nil {
  8896  		return nil, err
  8897  	}
  8898  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  8899  }
  8900  
  8901  // Call invokes the (constant) contract method with params as input values and
  8902  // sets the output to result. The result type might be a single field for simple
  8903  // returns, a slice of interfaces for anonymous returns and a struct for named
  8904  // returns.
  8905  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  8906  	return _MinterRoleRenounceTarget.Contract.MinterRoleRenounceTargetCaller.contract.Call(opts, result, method, params...)
  8907  }
  8908  
  8909  // Transfer initiates a plain transaction to move funds to the contract, calling
  8910  // its default method if one is available.
  8911  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  8912  	return _MinterRoleRenounceTarget.Contract.MinterRoleRenounceTargetTransactor.contract.Transfer(opts)
  8913  }
  8914  
  8915  // Transact invokes the (paid) contract method with params as input values.
  8916  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  8917  	return _MinterRoleRenounceTarget.Contract.MinterRoleRenounceTargetTransactor.contract.Transact(opts, method, params...)
  8918  }
  8919  
  8920  // Call invokes the (constant) contract method with params as input values and
  8921  // sets the output to result. The result type might be a single field for simple
  8922  // returns, a slice of interfaces for anonymous returns and a struct for named
  8923  // returns.
  8924  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  8925  	return _MinterRoleRenounceTarget.Contract.contract.Call(opts, result, method, params...)
  8926  }
  8927  
  8928  // Transfer initiates a plain transaction to move funds to the contract, calling
  8929  // its default method if one is available.
  8930  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  8931  	return _MinterRoleRenounceTarget.Contract.contract.Transfer(opts)
  8932  }
  8933  
  8934  // Transact invokes the (paid) contract method with params as input values.
  8935  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  8936  	return _MinterRoleRenounceTarget.Contract.contract.Transact(opts, method, params...)
  8937  }
  8938  
  8939  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  8940  //
  8941  // Solidity: function renounceMinter() returns()
  8942  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) {
  8943  	return _MinterRoleRenounceTarget.contract.Transact(opts, "renounceMinter")
  8944  }
  8945  
  8946  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  8947  //
  8948  // Solidity: function renounceMinter() returns()
  8949  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetSession) RenounceMinter() (*types.Transaction, error) {
  8950  	return _MinterRoleRenounceTarget.Contract.RenounceMinter(&_MinterRoleRenounceTarget.TransactOpts)
  8951  }
  8952  
  8953  // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275.
  8954  //
  8955  // Solidity: function renounceMinter() returns()
  8956  func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactorSession) RenounceMinter() (*types.Transaction, error) {
  8957  	return _MinterRoleRenounceTarget.Contract.RenounceMinter(&_MinterRoleRenounceTarget.TransactOpts)
  8958  }
  8959  
  8960  // OnApproveABI is the input ABI used to generate the binding from.
  8961  const OnApproveABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"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\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onApprove\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"
  8962  
  8963  // OnApproveFuncSigs maps the 4-byte function signature to its string representation.
  8964  var OnApproveFuncSigs = map[string]string{
  8965  	"6cd28f9a": "INTERFACE_ID_ON_APPROVE()",
  8966  	"4273ca16": "onApprove(address,address,uint256,bytes)",
  8967  	"01ffc9a7": "supportsInterface(bytes4)",
  8968  }
  8969  
  8970  // OnApprove is an auto generated Go binding around an Ethereum contract.
  8971  type OnApprove struct {
  8972  	OnApproveCaller     // Read-only binding to the contract
  8973  	OnApproveTransactor // Write-only binding to the contract
  8974  	OnApproveFilterer   // Log filterer for contract events
  8975  }
  8976  
  8977  // OnApproveCaller is an auto generated read-only Go binding around an Ethereum contract.
  8978  type OnApproveCaller struct {
  8979  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  8980  }
  8981  
  8982  // OnApproveTransactor is an auto generated write-only Go binding around an Ethereum contract.
  8983  type OnApproveTransactor struct {
  8984  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  8985  }
  8986  
  8987  // OnApproveFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  8988  type OnApproveFilterer struct {
  8989  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  8990  }
  8991  
  8992  // OnApproveSession is an auto generated Go binding around an Ethereum contract,
  8993  // with pre-set call and transact options.
  8994  type OnApproveSession struct {
  8995  	Contract     *OnApprove        // Generic contract binding to set the session for
  8996  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  8997  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  8998  }
  8999  
  9000  // OnApproveCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  9001  // with pre-set call options.
  9002  type OnApproveCallerSession struct {
  9003  	Contract *OnApproveCaller // Generic contract caller binding to set the session for
  9004  	CallOpts bind.CallOpts    // Call options to use throughout this session
  9005  }
  9006  
  9007  // OnApproveTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  9008  // with pre-set transact options.
  9009  type OnApproveTransactorSession struct {
  9010  	Contract     *OnApproveTransactor // Generic contract transactor binding to set the session for
  9011  	TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
  9012  }
  9013  
  9014  // OnApproveRaw is an auto generated low-level Go binding around an Ethereum contract.
  9015  type OnApproveRaw struct {
  9016  	Contract *OnApprove // Generic contract binding to access the raw methods on
  9017  }
  9018  
  9019  // OnApproveCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  9020  type OnApproveCallerRaw struct {
  9021  	Contract *OnApproveCaller // Generic read-only contract binding to access the raw methods on
  9022  }
  9023  
  9024  // OnApproveTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  9025  type OnApproveTransactorRaw struct {
  9026  	Contract *OnApproveTransactor // Generic write-only contract binding to access the raw methods on
  9027  }
  9028  
  9029  // NewOnApprove creates a new instance of OnApprove, bound to a specific deployed contract.
  9030  func NewOnApprove(address common.Address, backend bind.ContractBackend) (*OnApprove, error) {
  9031  	contract, err := bindOnApprove(address, backend, backend, backend)
  9032  	if err != nil {
  9033  		return nil, err
  9034  	}
  9035  	return &OnApprove{OnApproveCaller: OnApproveCaller{contract: contract}, OnApproveTransactor: OnApproveTransactor{contract: contract}, OnApproveFilterer: OnApproveFilterer{contract: contract}}, nil
  9036  }
  9037  
  9038  // NewOnApproveCaller creates a new read-only instance of OnApprove, bound to a specific deployed contract.
  9039  func NewOnApproveCaller(address common.Address, caller bind.ContractCaller) (*OnApproveCaller, error) {
  9040  	contract, err := bindOnApprove(address, caller, nil, nil)
  9041  	if err != nil {
  9042  		return nil, err
  9043  	}
  9044  	return &OnApproveCaller{contract: contract}, nil
  9045  }
  9046  
  9047  // NewOnApproveTransactor creates a new write-only instance of OnApprove, bound to a specific deployed contract.
  9048  func NewOnApproveTransactor(address common.Address, transactor bind.ContractTransactor) (*OnApproveTransactor, error) {
  9049  	contract, err := bindOnApprove(address, nil, transactor, nil)
  9050  	if err != nil {
  9051  		return nil, err
  9052  	}
  9053  	return &OnApproveTransactor{contract: contract}, nil
  9054  }
  9055  
  9056  // NewOnApproveFilterer creates a new log filterer instance of OnApprove, bound to a specific deployed contract.
  9057  func NewOnApproveFilterer(address common.Address, filterer bind.ContractFilterer) (*OnApproveFilterer, error) {
  9058  	contract, err := bindOnApprove(address, nil, nil, filterer)
  9059  	if err != nil {
  9060  		return nil, err
  9061  	}
  9062  	return &OnApproveFilterer{contract: contract}, nil
  9063  }
  9064  
  9065  // bindOnApprove binds a generic wrapper to an already deployed contract.
  9066  func bindOnApprove(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  9067  	parsed, err := abi.JSON(strings.NewReader(OnApproveABI))
  9068  	if err != nil {
  9069  		return nil, err
  9070  	}
  9071  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  9072  }
  9073  
  9074  // Call invokes the (constant) contract method with params as input values and
  9075  // sets the output to result. The result type might be a single field for simple
  9076  // returns, a slice of interfaces for anonymous returns and a struct for named
  9077  // returns.
  9078  func (_OnApprove *OnApproveRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  9079  	return _OnApprove.Contract.OnApproveCaller.contract.Call(opts, result, method, params...)
  9080  }
  9081  
  9082  // Transfer initiates a plain transaction to move funds to the contract, calling
  9083  // its default method if one is available.
  9084  func (_OnApprove *OnApproveRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  9085  	return _OnApprove.Contract.OnApproveTransactor.contract.Transfer(opts)
  9086  }
  9087  
  9088  // Transact invokes the (paid) contract method with params as input values.
  9089  func (_OnApprove *OnApproveRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  9090  	return _OnApprove.Contract.OnApproveTransactor.contract.Transact(opts, method, params...)
  9091  }
  9092  
  9093  // Call invokes the (constant) contract method with params as input values and
  9094  // sets the output to result. The result type might be a single field for simple
  9095  // returns, a slice of interfaces for anonymous returns and a struct for named
  9096  // returns.
  9097  func (_OnApprove *OnApproveCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  9098  	return _OnApprove.Contract.contract.Call(opts, result, method, params...)
  9099  }
  9100  
  9101  // Transfer initiates a plain transaction to move funds to the contract, calling
  9102  // its default method if one is available.
  9103  func (_OnApprove *OnApproveTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  9104  	return _OnApprove.Contract.contract.Transfer(opts)
  9105  }
  9106  
  9107  // Transact invokes the (paid) contract method with params as input values.
  9108  func (_OnApprove *OnApproveTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  9109  	return _OnApprove.Contract.contract.Transact(opts, method, params...)
  9110  }
  9111  
  9112  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  9113  //
  9114  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  9115  func (_OnApprove *OnApproveCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) {
  9116  	var (
  9117  		ret0 = new([4]byte)
  9118  	)
  9119  	out := ret0
  9120  	err := _OnApprove.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE")
  9121  	return *ret0, err
  9122  }
  9123  
  9124  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  9125  //
  9126  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  9127  func (_OnApprove *OnApproveSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  9128  	return _OnApprove.Contract.INTERFACEIDONAPPROVE(&_OnApprove.CallOpts)
  9129  }
  9130  
  9131  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  9132  //
  9133  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  9134  func (_OnApprove *OnApproveCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  9135  	return _OnApprove.Contract.INTERFACEIDONAPPROVE(&_OnApprove.CallOpts)
  9136  }
  9137  
  9138  // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
  9139  //
  9140  // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool)
  9141  func (_OnApprove *OnApproveCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
  9142  	var (
  9143  		ret0 = new(bool)
  9144  	)
  9145  	out := ret0
  9146  	err := _OnApprove.contract.Call(opts, out, "supportsInterface", interfaceId)
  9147  	return *ret0, err
  9148  }
  9149  
  9150  // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
  9151  //
  9152  // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool)
  9153  func (_OnApprove *OnApproveSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
  9154  	return _OnApprove.Contract.SupportsInterface(&_OnApprove.CallOpts, interfaceId)
  9155  }
  9156  
  9157  // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
  9158  //
  9159  // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool)
  9160  func (_OnApprove *OnApproveCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
  9161  	return _OnApprove.Contract.SupportsInterface(&_OnApprove.CallOpts, interfaceId)
  9162  }
  9163  
  9164  // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16.
  9165  //
  9166  // Solidity: function onApprove(address owner, address spender, uint256 amount, bytes data) returns(bool)
  9167  func (_OnApprove *OnApproveTransactor) OnApprove(opts *bind.TransactOpts, owner common.Address, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  9168  	return _OnApprove.contract.Transact(opts, "onApprove", owner, spender, amount, data)
  9169  }
  9170  
  9171  // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16.
  9172  //
  9173  // Solidity: function onApprove(address owner, address spender, uint256 amount, bytes data) returns(bool)
  9174  func (_OnApprove *OnApproveSession) OnApprove(owner common.Address, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  9175  	return _OnApprove.Contract.OnApprove(&_OnApprove.TransactOpts, owner, spender, amount, data)
  9176  }
  9177  
  9178  // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16.
  9179  //
  9180  // Solidity: function onApprove(address owner, address spender, uint256 amount, bytes data) returns(bool)
  9181  func (_OnApprove *OnApproveTransactorSession) OnApprove(owner common.Address, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
  9182  	return _OnApprove.Contract.OnApprove(&_OnApprove.TransactOpts, owner, spender, amount, data)
  9183  }
  9184  
  9185  // OnApproveConstantABI is the input ABI used to generate the binding from.
  9186  const OnApproveConstantABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"INTERFACE_ID_ON_APPROVE\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"
  9187  
  9188  // OnApproveConstantFuncSigs maps the 4-byte function signature to its string representation.
  9189  var OnApproveConstantFuncSigs = map[string]string{
  9190  	"6cd28f9a": "INTERFACE_ID_ON_APPROVE()",
  9191  }
  9192  
  9193  // OnApproveConstantBin is the compiled bytecode used for deploying new contracts.
  9194  var OnApproveConstantBin = "0x6080604052348015600f57600080fd5b5060c78061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c80636cd28f9a14602d575b600080fd5b60336050565b604080516001600160e01b03199092168252519081900360200190f35b604051806028606b8239602801905060405180910390208156fe6f6e417070726f766528616464726573732c616464726573732c75696e743235362c627974657329a265627a7a723158206d94182e39f46cad6425154650e56ecd40259e07a64364bd131e67fe91c85c7664736f6c634300050c0032"
  9195  
  9196  // DeployOnApproveConstant deploys a new Ethereum contract, binding an instance of OnApproveConstant to it.
  9197  func DeployOnApproveConstant(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *OnApproveConstant, error) {
  9198  	parsed, err := abi.JSON(strings.NewReader(OnApproveConstantABI))
  9199  	if err != nil {
  9200  		return common.Address{}, nil, nil, err
  9201  	}
  9202  
  9203  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(OnApproveConstantBin), backend)
  9204  	if err != nil {
  9205  		return common.Address{}, nil, nil, err
  9206  	}
  9207  	return address, tx, &OnApproveConstant{OnApproveConstantCaller: OnApproveConstantCaller{contract: contract}, OnApproveConstantTransactor: OnApproveConstantTransactor{contract: contract}, OnApproveConstantFilterer: OnApproveConstantFilterer{contract: contract}}, nil
  9208  }
  9209  
  9210  // OnApproveConstant is an auto generated Go binding around an Ethereum contract.
  9211  type OnApproveConstant struct {
  9212  	OnApproveConstantCaller     // Read-only binding to the contract
  9213  	OnApproveConstantTransactor // Write-only binding to the contract
  9214  	OnApproveConstantFilterer   // Log filterer for contract events
  9215  }
  9216  
  9217  // OnApproveConstantCaller is an auto generated read-only Go binding around an Ethereum contract.
  9218  type OnApproveConstantCaller struct {
  9219  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  9220  }
  9221  
  9222  // OnApproveConstantTransactor is an auto generated write-only Go binding around an Ethereum contract.
  9223  type OnApproveConstantTransactor struct {
  9224  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  9225  }
  9226  
  9227  // OnApproveConstantFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  9228  type OnApproveConstantFilterer struct {
  9229  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  9230  }
  9231  
  9232  // OnApproveConstantSession is an auto generated Go binding around an Ethereum contract,
  9233  // with pre-set call and transact options.
  9234  type OnApproveConstantSession struct {
  9235  	Contract     *OnApproveConstant // Generic contract binding to set the session for
  9236  	CallOpts     bind.CallOpts      // Call options to use throughout this session
  9237  	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
  9238  }
  9239  
  9240  // OnApproveConstantCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  9241  // with pre-set call options.
  9242  type OnApproveConstantCallerSession struct {
  9243  	Contract *OnApproveConstantCaller // Generic contract caller binding to set the session for
  9244  	CallOpts bind.CallOpts            // Call options to use throughout this session
  9245  }
  9246  
  9247  // OnApproveConstantTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  9248  // with pre-set transact options.
  9249  type OnApproveConstantTransactorSession struct {
  9250  	Contract     *OnApproveConstantTransactor // Generic contract transactor binding to set the session for
  9251  	TransactOpts bind.TransactOpts            // Transaction auth options to use throughout this session
  9252  }
  9253  
  9254  // OnApproveConstantRaw is an auto generated low-level Go binding around an Ethereum contract.
  9255  type OnApproveConstantRaw struct {
  9256  	Contract *OnApproveConstant // Generic contract binding to access the raw methods on
  9257  }
  9258  
  9259  // OnApproveConstantCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  9260  type OnApproveConstantCallerRaw struct {
  9261  	Contract *OnApproveConstantCaller // Generic read-only contract binding to access the raw methods on
  9262  }
  9263  
  9264  // OnApproveConstantTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  9265  type OnApproveConstantTransactorRaw struct {
  9266  	Contract *OnApproveConstantTransactor // Generic write-only contract binding to access the raw methods on
  9267  }
  9268  
  9269  // NewOnApproveConstant creates a new instance of OnApproveConstant, bound to a specific deployed contract.
  9270  func NewOnApproveConstant(address common.Address, backend bind.ContractBackend) (*OnApproveConstant, error) {
  9271  	contract, err := bindOnApproveConstant(address, backend, backend, backend)
  9272  	if err != nil {
  9273  		return nil, err
  9274  	}
  9275  	return &OnApproveConstant{OnApproveConstantCaller: OnApproveConstantCaller{contract: contract}, OnApproveConstantTransactor: OnApproveConstantTransactor{contract: contract}, OnApproveConstantFilterer: OnApproveConstantFilterer{contract: contract}}, nil
  9276  }
  9277  
  9278  // NewOnApproveConstantCaller creates a new read-only instance of OnApproveConstant, bound to a specific deployed contract.
  9279  func NewOnApproveConstantCaller(address common.Address, caller bind.ContractCaller) (*OnApproveConstantCaller, error) {
  9280  	contract, err := bindOnApproveConstant(address, caller, nil, nil)
  9281  	if err != nil {
  9282  		return nil, err
  9283  	}
  9284  	return &OnApproveConstantCaller{contract: contract}, nil
  9285  }
  9286  
  9287  // NewOnApproveConstantTransactor creates a new write-only instance of OnApproveConstant, bound to a specific deployed contract.
  9288  func NewOnApproveConstantTransactor(address common.Address, transactor bind.ContractTransactor) (*OnApproveConstantTransactor, error) {
  9289  	contract, err := bindOnApproveConstant(address, nil, transactor, nil)
  9290  	if err != nil {
  9291  		return nil, err
  9292  	}
  9293  	return &OnApproveConstantTransactor{contract: contract}, nil
  9294  }
  9295  
  9296  // NewOnApproveConstantFilterer creates a new log filterer instance of OnApproveConstant, bound to a specific deployed contract.
  9297  func NewOnApproveConstantFilterer(address common.Address, filterer bind.ContractFilterer) (*OnApproveConstantFilterer, error) {
  9298  	contract, err := bindOnApproveConstant(address, nil, nil, filterer)
  9299  	if err != nil {
  9300  		return nil, err
  9301  	}
  9302  	return &OnApproveConstantFilterer{contract: contract}, nil
  9303  }
  9304  
  9305  // bindOnApproveConstant binds a generic wrapper to an already deployed contract.
  9306  func bindOnApproveConstant(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  9307  	parsed, err := abi.JSON(strings.NewReader(OnApproveConstantABI))
  9308  	if err != nil {
  9309  		return nil, err
  9310  	}
  9311  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  9312  }
  9313  
  9314  // Call invokes the (constant) contract method with params as input values and
  9315  // sets the output to result. The result type might be a single field for simple
  9316  // returns, a slice of interfaces for anonymous returns and a struct for named
  9317  // returns.
  9318  func (_OnApproveConstant *OnApproveConstantRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  9319  	return _OnApproveConstant.Contract.OnApproveConstantCaller.contract.Call(opts, result, method, params...)
  9320  }
  9321  
  9322  // Transfer initiates a plain transaction to move funds to the contract, calling
  9323  // its default method if one is available.
  9324  func (_OnApproveConstant *OnApproveConstantRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  9325  	return _OnApproveConstant.Contract.OnApproveConstantTransactor.contract.Transfer(opts)
  9326  }
  9327  
  9328  // Transact invokes the (paid) contract method with params as input values.
  9329  func (_OnApproveConstant *OnApproveConstantRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  9330  	return _OnApproveConstant.Contract.OnApproveConstantTransactor.contract.Transact(opts, method, params...)
  9331  }
  9332  
  9333  // Call invokes the (constant) contract method with params as input values and
  9334  // sets the output to result. The result type might be a single field for simple
  9335  // returns, a slice of interfaces for anonymous returns and a struct for named
  9336  // returns.
  9337  func (_OnApproveConstant *OnApproveConstantCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  9338  	return _OnApproveConstant.Contract.contract.Call(opts, result, method, params...)
  9339  }
  9340  
  9341  // Transfer initiates a plain transaction to move funds to the contract, calling
  9342  // its default method if one is available.
  9343  func (_OnApproveConstant *OnApproveConstantTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  9344  	return _OnApproveConstant.Contract.contract.Transfer(opts)
  9345  }
  9346  
  9347  // Transact invokes the (paid) contract method with params as input values.
  9348  func (_OnApproveConstant *OnApproveConstantTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  9349  	return _OnApproveConstant.Contract.contract.Transact(opts, method, params...)
  9350  }
  9351  
  9352  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  9353  //
  9354  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  9355  func (_OnApproveConstant *OnApproveConstantCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) {
  9356  	var (
  9357  		ret0 = new([4]byte)
  9358  	)
  9359  	out := ret0
  9360  	err := _OnApproveConstant.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE")
  9361  	return *ret0, err
  9362  }
  9363  
  9364  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  9365  //
  9366  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  9367  func (_OnApproveConstant *OnApproveConstantSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  9368  	return _OnApproveConstant.Contract.INTERFACEIDONAPPROVE(&_OnApproveConstant.CallOpts)
  9369  }
  9370  
  9371  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
  9372  //
  9373  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
  9374  func (_OnApproveConstant *OnApproveConstantCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
  9375  	return _OnApproveConstant.Contract.INTERFACEIDONAPPROVE(&_OnApproveConstant.CallOpts)
  9376  }
  9377  
  9378  // OwnableABI is the input ABI used to generate the binding from.
  9379  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\"}]"
  9380  
  9381  // OwnableFuncSigs maps the 4-byte function signature to its string representation.
  9382  var OwnableFuncSigs = map[string]string{
  9383  	"8f32d59b": "isOwner()",
  9384  	"8da5cb5b": "owner()",
  9385  	"715018a6": "renounceOwnership()",
  9386  	"f2fde38b": "transferOwnership(address)",
  9387  }
  9388  
  9389  // Ownable is an auto generated Go binding around an Ethereum contract.
  9390  type Ownable struct {
  9391  	OwnableCaller     // Read-only binding to the contract
  9392  	OwnableTransactor // Write-only binding to the contract
  9393  	OwnableFilterer   // Log filterer for contract events
  9394  }
  9395  
  9396  // OwnableCaller is an auto generated read-only Go binding around an Ethereum contract.
  9397  type OwnableCaller struct {
  9398  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  9399  }
  9400  
  9401  // OwnableTransactor is an auto generated write-only Go binding around an Ethereum contract.
  9402  type OwnableTransactor struct {
  9403  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  9404  }
  9405  
  9406  // OwnableFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  9407  type OwnableFilterer struct {
  9408  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  9409  }
  9410  
  9411  // OwnableSession is an auto generated Go binding around an Ethereum contract,
  9412  // with pre-set call and transact options.
  9413  type OwnableSession struct {
  9414  	Contract     *Ownable          // Generic contract binding to set the session for
  9415  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  9416  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  9417  }
  9418  
  9419  // OwnableCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  9420  // with pre-set call options.
  9421  type OwnableCallerSession struct {
  9422  	Contract *OwnableCaller // Generic contract caller binding to set the session for
  9423  	CallOpts bind.CallOpts  // Call options to use throughout this session
  9424  }
  9425  
  9426  // OwnableTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  9427  // with pre-set transact options.
  9428  type OwnableTransactorSession struct {
  9429  	Contract     *OwnableTransactor // Generic contract transactor binding to set the session for
  9430  	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
  9431  }
  9432  
  9433  // OwnableRaw is an auto generated low-level Go binding around an Ethereum contract.
  9434  type OwnableRaw struct {
  9435  	Contract *Ownable // Generic contract binding to access the raw methods on
  9436  }
  9437  
  9438  // OwnableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  9439  type OwnableCallerRaw struct {
  9440  	Contract *OwnableCaller // Generic read-only contract binding to access the raw methods on
  9441  }
  9442  
  9443  // OwnableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  9444  type OwnableTransactorRaw struct {
  9445  	Contract *OwnableTransactor // Generic write-only contract binding to access the raw methods on
  9446  }
  9447  
  9448  // NewOwnable creates a new instance of Ownable, bound to a specific deployed contract.
  9449  func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error) {
  9450  	contract, err := bindOwnable(address, backend, backend, backend)
  9451  	if err != nil {
  9452  		return nil, err
  9453  	}
  9454  	return &Ownable{OwnableCaller: OwnableCaller{contract: contract}, OwnableTransactor: OwnableTransactor{contract: contract}, OwnableFilterer: OwnableFilterer{contract: contract}}, nil
  9455  }
  9456  
  9457  // NewOwnableCaller creates a new read-only instance of Ownable, bound to a specific deployed contract.
  9458  func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error) {
  9459  	contract, err := bindOwnable(address, caller, nil, nil)
  9460  	if err != nil {
  9461  		return nil, err
  9462  	}
  9463  	return &OwnableCaller{contract: contract}, nil
  9464  }
  9465  
  9466  // NewOwnableTransactor creates a new write-only instance of Ownable, bound to a specific deployed contract.
  9467  func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error) {
  9468  	contract, err := bindOwnable(address, nil, transactor, nil)
  9469  	if err != nil {
  9470  		return nil, err
  9471  	}
  9472  	return &OwnableTransactor{contract: contract}, nil
  9473  }
  9474  
  9475  // NewOwnableFilterer creates a new log filterer instance of Ownable, bound to a specific deployed contract.
  9476  func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error) {
  9477  	contract, err := bindOwnable(address, nil, nil, filterer)
  9478  	if err != nil {
  9479  		return nil, err
  9480  	}
  9481  	return &OwnableFilterer{contract: contract}, nil
  9482  }
  9483  
  9484  // bindOwnable binds a generic wrapper to an already deployed contract.
  9485  func bindOwnable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  9486  	parsed, err := abi.JSON(strings.NewReader(OwnableABI))
  9487  	if err != nil {
  9488  		return nil, err
  9489  	}
  9490  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  9491  }
  9492  
  9493  // Call invokes the (constant) contract method with params as input values and
  9494  // sets the output to result. The result type might be a single field for simple
  9495  // returns, a slice of interfaces for anonymous returns and a struct for named
  9496  // returns.
  9497  func (_Ownable *OwnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  9498  	return _Ownable.Contract.OwnableCaller.contract.Call(opts, result, method, params...)
  9499  }
  9500  
  9501  // Transfer initiates a plain transaction to move funds to the contract, calling
  9502  // its default method if one is available.
  9503  func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  9504  	return _Ownable.Contract.OwnableTransactor.contract.Transfer(opts)
  9505  }
  9506  
  9507  // Transact invokes the (paid) contract method with params as input values.
  9508  func (_Ownable *OwnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  9509  	return _Ownable.Contract.OwnableTransactor.contract.Transact(opts, method, params...)
  9510  }
  9511  
  9512  // Call invokes the (constant) contract method with params as input values and
  9513  // sets the output to result. The result type might be a single field for simple
  9514  // returns, a slice of interfaces for anonymous returns and a struct for named
  9515  // returns.
  9516  func (_Ownable *OwnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  9517  	return _Ownable.Contract.contract.Call(opts, result, method, params...)
  9518  }
  9519  
  9520  // Transfer initiates a plain transaction to move funds to the contract, calling
  9521  // its default method if one is available.
  9522  func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  9523  	return _Ownable.Contract.contract.Transfer(opts)
  9524  }
  9525  
  9526  // Transact invokes the (paid) contract method with params as input values.
  9527  func (_Ownable *OwnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  9528  	return _Ownable.Contract.contract.Transact(opts, method, params...)
  9529  }
  9530  
  9531  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
  9532  //
  9533  // Solidity: function isOwner() constant returns(bool)
  9534  func (_Ownable *OwnableCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
  9535  	var (
  9536  		ret0 = new(bool)
  9537  	)
  9538  	out := ret0
  9539  	err := _Ownable.contract.Call(opts, out, "isOwner")
  9540  	return *ret0, err
  9541  }
  9542  
  9543  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
  9544  //
  9545  // Solidity: function isOwner() constant returns(bool)
  9546  func (_Ownable *OwnableSession) IsOwner() (bool, error) {
  9547  	return _Ownable.Contract.IsOwner(&_Ownable.CallOpts)
  9548  }
  9549  
  9550  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
  9551  //
  9552  // Solidity: function isOwner() constant returns(bool)
  9553  func (_Ownable *OwnableCallerSession) IsOwner() (bool, error) {
  9554  	return _Ownable.Contract.IsOwner(&_Ownable.CallOpts)
  9555  }
  9556  
  9557  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  9558  //
  9559  // Solidity: function owner() constant returns(address)
  9560  func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
  9561  	var (
  9562  		ret0 = new(common.Address)
  9563  	)
  9564  	out := ret0
  9565  	err := _Ownable.contract.Call(opts, out, "owner")
  9566  	return *ret0, err
  9567  }
  9568  
  9569  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  9570  //
  9571  // Solidity: function owner() constant returns(address)
  9572  func (_Ownable *OwnableSession) Owner() (common.Address, error) {
  9573  	return _Ownable.Contract.Owner(&_Ownable.CallOpts)
  9574  }
  9575  
  9576  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
  9577  //
  9578  // Solidity: function owner() constant returns(address)
  9579  func (_Ownable *OwnableCallerSession) Owner() (common.Address, error) {
  9580  	return _Ownable.Contract.Owner(&_Ownable.CallOpts)
  9581  }
  9582  
  9583  // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
  9584  //
  9585  // Solidity: function renounceOwnership() returns()
  9586  func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
  9587  	return _Ownable.contract.Transact(opts, "renounceOwnership")
  9588  }
  9589  
  9590  // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
  9591  //
  9592  // Solidity: function renounceOwnership() returns()
  9593  func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, error) {
  9594  	return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts)
  9595  }
  9596  
  9597  // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
  9598  //
  9599  // Solidity: function renounceOwnership() returns()
  9600  func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, error) {
  9601  	return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts)
  9602  }
  9603  
  9604  // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
  9605  //
  9606  // Solidity: function transferOwnership(address newOwner) returns()
  9607  func (_Ownable *OwnableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
  9608  	return _Ownable.contract.Transact(opts, "transferOwnership", newOwner)
  9609  }
  9610  
  9611  // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
  9612  //
  9613  // Solidity: function transferOwnership(address newOwner) returns()
  9614  func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
  9615  	return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner)
  9616  }
  9617  
  9618  // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
  9619  //
  9620  // Solidity: function transferOwnership(address newOwner) returns()
  9621  func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
  9622  	return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner)
  9623  }
  9624  
  9625  // 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.
  9626  type OwnableOwnershipTransferredIterator struct {
  9627  	Event *OwnableOwnershipTransferred // Event containing the contract specifics and raw log
  9628  
  9629  	contract *bind.BoundContract // Generic contract to use for unpacking event data
  9630  	event    string              // Event name to use for unpacking event data
  9631  
  9632  	logs chan types.Log        // Log channel receiving the found contract events
  9633  	sub  ethereum.Subscription // Subscription for errors, completion and termination
  9634  	done bool                  // Whether the subscription completed delivering logs
  9635  	fail error                 // Occurred error to stop iteration
  9636  }
  9637  
  9638  // Next advances the iterator to the subsequent event, returning whether there
  9639  // are any more events found. In case of a retrieval or parsing error, false is
  9640  // returned and Error() can be queried for the exact failure.
  9641  func (it *OwnableOwnershipTransferredIterator) Next() bool {
  9642  	// If the iterator failed, stop iterating
  9643  	if it.fail != nil {
  9644  		return false
  9645  	}
  9646  	// If the iterator completed, deliver directly whatever's available
  9647  	if it.done {
  9648  		select {
  9649  		case log := <-it.logs:
  9650  			it.Event = new(OwnableOwnershipTransferred)
  9651  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  9652  				it.fail = err
  9653  				return false
  9654  			}
  9655  			it.Event.Raw = log
  9656  			return true
  9657  
  9658  		default:
  9659  			return false
  9660  		}
  9661  	}
  9662  	// Iterator still in progress, wait for either a data or an error event
  9663  	select {
  9664  	case log := <-it.logs:
  9665  		it.Event = new(OwnableOwnershipTransferred)
  9666  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
  9667  			it.fail = err
  9668  			return false
  9669  		}
  9670  		it.Event.Raw = log
  9671  		return true
  9672  
  9673  	case err := <-it.sub.Err():
  9674  		it.done = true
  9675  		it.fail = err
  9676  		return it.Next()
  9677  	}
  9678  }
  9679  
  9680  // Error returns any retrieval or parsing error occurred during filtering.
  9681  func (it *OwnableOwnershipTransferredIterator) Error() error {
  9682  	return it.fail
  9683  }
  9684  
  9685  // Close terminates the iteration process, releasing any pending underlying
  9686  // resources.
  9687  func (it *OwnableOwnershipTransferredIterator) Close() error {
  9688  	it.sub.Unsubscribe()
  9689  	return nil
  9690  }
  9691  
  9692  // OwnableOwnershipTransferred represents a OwnershipTransferred event raised by the Ownable contract.
  9693  type OwnableOwnershipTransferred struct {
  9694  	PreviousOwner common.Address
  9695  	NewOwner      common.Address
  9696  	Raw           types.Log // Blockchain specific contextual infos
  9697  }
  9698  
  9699  // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
  9700  //
  9701  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
  9702  func (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*OwnableOwnershipTransferredIterator, error) {
  9703  
  9704  	var previousOwnerRule []interface{}
  9705  	for _, previousOwnerItem := range previousOwner {
  9706  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
  9707  	}
  9708  	var newOwnerRule []interface{}
  9709  	for _, newOwnerItem := range newOwner {
  9710  		newOwnerRule = append(newOwnerRule, newOwnerItem)
  9711  	}
  9712  
  9713  	logs, sub, err := _Ownable.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
  9714  	if err != nil {
  9715  		return nil, err
  9716  	}
  9717  	return &OwnableOwnershipTransferredIterator{contract: _Ownable.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
  9718  }
  9719  
  9720  // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
  9721  //
  9722  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
  9723  func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {
  9724  
  9725  	var previousOwnerRule []interface{}
  9726  	for _, previousOwnerItem := range previousOwner {
  9727  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
  9728  	}
  9729  	var newOwnerRule []interface{}
  9730  	for _, newOwnerItem := range newOwner {
  9731  		newOwnerRule = append(newOwnerRule, newOwnerItem)
  9732  	}
  9733  
  9734  	logs, sub, err := _Ownable.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
  9735  	if err != nil {
  9736  		return nil, err
  9737  	}
  9738  	return event.NewSubscription(func(quit <-chan struct{}) error {
  9739  		defer sub.Unsubscribe()
  9740  		for {
  9741  			select {
  9742  			case log := <-logs:
  9743  				// New log arrived, parse the event and forward to the user
  9744  				event := new(OwnableOwnershipTransferred)
  9745  				if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
  9746  					return err
  9747  				}
  9748  				event.Raw = log
  9749  
  9750  				select {
  9751  				case sink <- event:
  9752  				case err := <-sub.Err():
  9753  					return err
  9754  				case <-quit:
  9755  					return nil
  9756  				}
  9757  			case err := <-sub.Err():
  9758  				return err
  9759  			case <-quit:
  9760  				return nil
  9761  			}
  9762  		}
  9763  	}), nil
  9764  }
  9765  
  9766  // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
  9767  //
  9768  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
  9769  func (_Ownable *OwnableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnableOwnershipTransferred, error) {
  9770  	event := new(OwnableOwnershipTransferred)
  9771  	if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
  9772  		return nil, err
  9773  	}
  9774  	return event, nil
  9775  }
  9776  
  9777  // OwnableTargetABI is the input ABI used to generate the binding from.
  9778  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\"}]"
  9779  
  9780  // OwnableTargetFuncSigs maps the 4-byte function signature to its string representation.
  9781  var OwnableTargetFuncSigs = map[string]string{
  9782  	"715018a6": "renounceOwnership()",
  9783  	"f2fde38b": "transferOwnership(address)",
  9784  }
  9785  
  9786  // OwnableTarget is an auto generated Go binding around an Ethereum contract.
  9787  type OwnableTarget struct {
  9788  	OwnableTargetCaller     // Read-only binding to the contract
  9789  	OwnableTargetTransactor // Write-only binding to the contract
  9790  	OwnableTargetFilterer   // Log filterer for contract events
  9791  }
  9792  
  9793  // OwnableTargetCaller is an auto generated read-only Go binding around an Ethereum contract.
  9794  type OwnableTargetCaller struct {
  9795  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  9796  }
  9797  
  9798  // OwnableTargetTransactor is an auto generated write-only Go binding around an Ethereum contract.
  9799  type OwnableTargetTransactor struct {
  9800  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  9801  }
  9802  
  9803  // OwnableTargetFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  9804  type OwnableTargetFilterer struct {
  9805  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  9806  }
  9807  
  9808  // OwnableTargetSession is an auto generated Go binding around an Ethereum contract,
  9809  // with pre-set call and transact options.
  9810  type OwnableTargetSession struct {
  9811  	Contract     *OwnableTarget    // Generic contract binding to set the session for
  9812  	CallOpts     bind.CallOpts     // Call options to use throughout this session
  9813  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
  9814  }
  9815  
  9816  // OwnableTargetCallerSession is an auto generated read-only Go binding around an Ethereum contract,
  9817  // with pre-set call options.
  9818  type OwnableTargetCallerSession struct {
  9819  	Contract *OwnableTargetCaller // Generic contract caller binding to set the session for
  9820  	CallOpts bind.CallOpts        // Call options to use throughout this session
  9821  }
  9822  
  9823  // OwnableTargetTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
  9824  // with pre-set transact options.
  9825  type OwnableTargetTransactorSession struct {
  9826  	Contract     *OwnableTargetTransactor // Generic contract transactor binding to set the session for
  9827  	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
  9828  }
  9829  
  9830  // OwnableTargetRaw is an auto generated low-level Go binding around an Ethereum contract.
  9831  type OwnableTargetRaw struct {
  9832  	Contract *OwnableTarget // Generic contract binding to access the raw methods on
  9833  }
  9834  
  9835  // OwnableTargetCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
  9836  type OwnableTargetCallerRaw struct {
  9837  	Contract *OwnableTargetCaller // Generic read-only contract binding to access the raw methods on
  9838  }
  9839  
  9840  // OwnableTargetTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
  9841  type OwnableTargetTransactorRaw struct {
  9842  	Contract *OwnableTargetTransactor // Generic write-only contract binding to access the raw methods on
  9843  }
  9844  
  9845  // NewOwnableTarget creates a new instance of OwnableTarget, bound to a specific deployed contract.
  9846  func NewOwnableTarget(address common.Address, backend bind.ContractBackend) (*OwnableTarget, error) {
  9847  	contract, err := bindOwnableTarget(address, backend, backend, backend)
  9848  	if err != nil {
  9849  		return nil, err
  9850  	}
  9851  	return &OwnableTarget{OwnableTargetCaller: OwnableTargetCaller{contract: contract}, OwnableTargetTransactor: OwnableTargetTransactor{contract: contract}, OwnableTargetFilterer: OwnableTargetFilterer{contract: contract}}, nil
  9852  }
  9853  
  9854  // NewOwnableTargetCaller creates a new read-only instance of OwnableTarget, bound to a specific deployed contract.
  9855  func NewOwnableTargetCaller(address common.Address, caller bind.ContractCaller) (*OwnableTargetCaller, error) {
  9856  	contract, err := bindOwnableTarget(address, caller, nil, nil)
  9857  	if err != nil {
  9858  		return nil, err
  9859  	}
  9860  	return &OwnableTargetCaller{contract: contract}, nil
  9861  }
  9862  
  9863  // NewOwnableTargetTransactor creates a new write-only instance of OwnableTarget, bound to a specific deployed contract.
  9864  func NewOwnableTargetTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTargetTransactor, error) {
  9865  	contract, err := bindOwnableTarget(address, nil, transactor, nil)
  9866  	if err != nil {
  9867  		return nil, err
  9868  	}
  9869  	return &OwnableTargetTransactor{contract: contract}, nil
  9870  }
  9871  
  9872  // NewOwnableTargetFilterer creates a new log filterer instance of OwnableTarget, bound to a specific deployed contract.
  9873  func NewOwnableTargetFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableTargetFilterer, error) {
  9874  	contract, err := bindOwnableTarget(address, nil, nil, filterer)
  9875  	if err != nil {
  9876  		return nil, err
  9877  	}
  9878  	return &OwnableTargetFilterer{contract: contract}, nil
  9879  }
  9880  
  9881  // bindOwnableTarget binds a generic wrapper to an already deployed contract.
  9882  func bindOwnableTarget(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
  9883  	parsed, err := abi.JSON(strings.NewReader(OwnableTargetABI))
  9884  	if err != nil {
  9885  		return nil, err
  9886  	}
  9887  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
  9888  }
  9889  
  9890  // Call invokes the (constant) contract method with params as input values and
  9891  // sets the output to result. The result type might be a single field for simple
  9892  // returns, a slice of interfaces for anonymous returns and a struct for named
  9893  // returns.
  9894  func (_OwnableTarget *OwnableTargetRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  9895  	return _OwnableTarget.Contract.OwnableTargetCaller.contract.Call(opts, result, method, params...)
  9896  }
  9897  
  9898  // Transfer initiates a plain transaction to move funds to the contract, calling
  9899  // its default method if one is available.
  9900  func (_OwnableTarget *OwnableTargetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  9901  	return _OwnableTarget.Contract.OwnableTargetTransactor.contract.Transfer(opts)
  9902  }
  9903  
  9904  // Transact invokes the (paid) contract method with params as input values.
  9905  func (_OwnableTarget *OwnableTargetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  9906  	return _OwnableTarget.Contract.OwnableTargetTransactor.contract.Transact(opts, method, params...)
  9907  }
  9908  
  9909  // Call invokes the (constant) contract method with params as input values and
  9910  // sets the output to result. The result type might be a single field for simple
  9911  // returns, a slice of interfaces for anonymous returns and a struct for named
  9912  // returns.
  9913  func (_OwnableTarget *OwnableTargetCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
  9914  	return _OwnableTarget.Contract.contract.Call(opts, result, method, params...)
  9915  }
  9916  
  9917  // Transfer initiates a plain transaction to move funds to the contract, calling
  9918  // its default method if one is available.
  9919  func (_OwnableTarget *OwnableTargetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
  9920  	return _OwnableTarget.Contract.contract.Transfer(opts)
  9921  }
  9922  
  9923  // Transact invokes the (paid) contract method with params as input values.
  9924  func (_OwnableTarget *OwnableTargetTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
  9925  	return _OwnableTarget.Contract.contract.Transact(opts, method, params...)
  9926  }
  9927  
  9928  // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
  9929  //
  9930  // Solidity: function renounceOwnership() returns()
  9931  func (_OwnableTarget *OwnableTargetTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
  9932  	return _OwnableTarget.contract.Transact(opts, "renounceOwnership")
  9933  }
  9934  
  9935  // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
  9936  //
  9937  // Solidity: function renounceOwnership() returns()
  9938  func (_OwnableTarget *OwnableTargetSession) RenounceOwnership() (*types.Transaction, error) {
  9939  	return _OwnableTarget.Contract.RenounceOwnership(&_OwnableTarget.TransactOpts)
  9940  }
  9941  
  9942  // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
  9943  //
  9944  // Solidity: function renounceOwnership() returns()
  9945  func (_OwnableTarget *OwnableTargetTransactorSession) RenounceOwnership() (*types.Transaction, error) {
  9946  	return _OwnableTarget.Contract.RenounceOwnership(&_OwnableTarget.TransactOpts)
  9947  }
  9948  
  9949  // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
  9950  //
  9951  // Solidity: function transferOwnership(address newOwner) returns()
  9952  func (_OwnableTarget *OwnableTargetTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
  9953  	return _OwnableTarget.contract.Transact(opts, "transferOwnership", newOwner)
  9954  }
  9955  
  9956  // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
  9957  //
  9958  // Solidity: function transferOwnership(address newOwner) returns()
  9959  func (_OwnableTarget *OwnableTargetSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
  9960  	return _OwnableTarget.Contract.TransferOwnership(&_OwnableTarget.TransactOpts, newOwner)
  9961  }
  9962  
  9963  // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
  9964  //
  9965  // Solidity: function transferOwnership(address newOwner) returns()
  9966  func (_OwnableTarget *OwnableTargetTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
  9967  	return _OwnableTarget.Contract.TransferOwnership(&_OwnableTarget.TransactOpts, newOwner)
  9968  }
  9969  
  9970  // PauserRoleRenounceTargetABI is the input ABI used to generate the binding from.
  9971  const PauserRoleRenounceTargetABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
  9972  
  9973  // PauserRoleRenounceTargetFuncSigs maps the 4-byte function signature to its string representation.
  9974  var PauserRoleRenounceTargetFuncSigs = map[string]string{
  9975  	"6ef8d66d": "renouncePauser()",
  9976  }
  9977  
  9978  // PauserRoleRenounceTarget is an auto generated Go binding around an Ethereum contract.
  9979  type PauserRoleRenounceTarget struct {
  9980  	PauserRoleRenounceTargetCaller     // Read-only binding to the contract
  9981  	PauserRoleRenounceTargetTransactor // Write-only binding to the contract
  9982  	PauserRoleRenounceTargetFilterer   // Log filterer for contract events
  9983  }
  9984  
  9985  // PauserRoleRenounceTargetCaller is an auto generated read-only Go binding around an Ethereum contract.
  9986  type PauserRoleRenounceTargetCaller struct {
  9987  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  9988  }
  9989  
  9990  // PauserRoleRenounceTargetTransactor is an auto generated write-only Go binding around an Ethereum contract.
  9991  type PauserRoleRenounceTargetTransactor struct {
  9992  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  9993  }
  9994  
  9995  // PauserRoleRenounceTargetFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
  9996  type PauserRoleRenounceTargetFilterer struct {
  9997  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
  9998  }
  9999  
 10000  // PauserRoleRenounceTargetSession is an auto generated Go binding around an Ethereum contract,
 10001  // with pre-set call and transact options.
 10002  type PauserRoleRenounceTargetSession struct {
 10003  	Contract     *PauserRoleRenounceTarget // Generic contract binding to set the session for
 10004  	CallOpts     bind.CallOpts             // Call options to use throughout this session
 10005  	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
 10006  }
 10007  
 10008  // PauserRoleRenounceTargetCallerSession is an auto generated read-only Go binding around an Ethereum contract,
 10009  // with pre-set call options.
 10010  type PauserRoleRenounceTargetCallerSession struct {
 10011  	Contract *PauserRoleRenounceTargetCaller // Generic contract caller binding to set the session for
 10012  	CallOpts bind.CallOpts                   // Call options to use throughout this session
 10013  }
 10014  
 10015  // PauserRoleRenounceTargetTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
 10016  // with pre-set transact options.
 10017  type PauserRoleRenounceTargetTransactorSession struct {
 10018  	Contract     *PauserRoleRenounceTargetTransactor // Generic contract transactor binding to set the session for
 10019  	TransactOpts bind.TransactOpts                   // Transaction auth options to use throughout this session
 10020  }
 10021  
 10022  // PauserRoleRenounceTargetRaw is an auto generated low-level Go binding around an Ethereum contract.
 10023  type PauserRoleRenounceTargetRaw struct {
 10024  	Contract *PauserRoleRenounceTarget // Generic contract binding to access the raw methods on
 10025  }
 10026  
 10027  // PauserRoleRenounceTargetCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
 10028  type PauserRoleRenounceTargetCallerRaw struct {
 10029  	Contract *PauserRoleRenounceTargetCaller // Generic read-only contract binding to access the raw methods on
 10030  }
 10031  
 10032  // PauserRoleRenounceTargetTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
 10033  type PauserRoleRenounceTargetTransactorRaw struct {
 10034  	Contract *PauserRoleRenounceTargetTransactor // Generic write-only contract binding to access the raw methods on
 10035  }
 10036  
 10037  // NewPauserRoleRenounceTarget creates a new instance of PauserRoleRenounceTarget, bound to a specific deployed contract.
 10038  func NewPauserRoleRenounceTarget(address common.Address, backend bind.ContractBackend) (*PauserRoleRenounceTarget, error) {
 10039  	contract, err := bindPauserRoleRenounceTarget(address, backend, backend, backend)
 10040  	if err != nil {
 10041  		return nil, err
 10042  	}
 10043  	return &PauserRoleRenounceTarget{PauserRoleRenounceTargetCaller: PauserRoleRenounceTargetCaller{contract: contract}, PauserRoleRenounceTargetTransactor: PauserRoleRenounceTargetTransactor{contract: contract}, PauserRoleRenounceTargetFilterer: PauserRoleRenounceTargetFilterer{contract: contract}}, nil
 10044  }
 10045  
 10046  // NewPauserRoleRenounceTargetCaller creates a new read-only instance of PauserRoleRenounceTarget, bound to a specific deployed contract.
 10047  func NewPauserRoleRenounceTargetCaller(address common.Address, caller bind.ContractCaller) (*PauserRoleRenounceTargetCaller, error) {
 10048  	contract, err := bindPauserRoleRenounceTarget(address, caller, nil, nil)
 10049  	if err != nil {
 10050  		return nil, err
 10051  	}
 10052  	return &PauserRoleRenounceTargetCaller{contract: contract}, nil
 10053  }
 10054  
 10055  // NewPauserRoleRenounceTargetTransactor creates a new write-only instance of PauserRoleRenounceTarget, bound to a specific deployed contract.
 10056  func NewPauserRoleRenounceTargetTransactor(address common.Address, transactor bind.ContractTransactor) (*PauserRoleRenounceTargetTransactor, error) {
 10057  	contract, err := bindPauserRoleRenounceTarget(address, nil, transactor, nil)
 10058  	if err != nil {
 10059  		return nil, err
 10060  	}
 10061  	return &PauserRoleRenounceTargetTransactor{contract: contract}, nil
 10062  }
 10063  
 10064  // NewPauserRoleRenounceTargetFilterer creates a new log filterer instance of PauserRoleRenounceTarget, bound to a specific deployed contract.
 10065  func NewPauserRoleRenounceTargetFilterer(address common.Address, filterer bind.ContractFilterer) (*PauserRoleRenounceTargetFilterer, error) {
 10066  	contract, err := bindPauserRoleRenounceTarget(address, nil, nil, filterer)
 10067  	if err != nil {
 10068  		return nil, err
 10069  	}
 10070  	return &PauserRoleRenounceTargetFilterer{contract: contract}, nil
 10071  }
 10072  
 10073  // bindPauserRoleRenounceTarget binds a generic wrapper to an already deployed contract.
 10074  func bindPauserRoleRenounceTarget(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 10075  	parsed, err := abi.JSON(strings.NewReader(PauserRoleRenounceTargetABI))
 10076  	if err != nil {
 10077  		return nil, err
 10078  	}
 10079  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 10080  }
 10081  
 10082  // Call invokes the (constant) contract method with params as input values and
 10083  // sets the output to result. The result type might be a single field for simple
 10084  // returns, a slice of interfaces for anonymous returns and a struct for named
 10085  // returns.
 10086  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 10087  	return _PauserRoleRenounceTarget.Contract.PauserRoleRenounceTargetCaller.contract.Call(opts, result, method, params...)
 10088  }
 10089  
 10090  // Transfer initiates a plain transaction to move funds to the contract, calling
 10091  // its default method if one is available.
 10092  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 10093  	return _PauserRoleRenounceTarget.Contract.PauserRoleRenounceTargetTransactor.contract.Transfer(opts)
 10094  }
 10095  
 10096  // Transact invokes the (paid) contract method with params as input values.
 10097  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 10098  	return _PauserRoleRenounceTarget.Contract.PauserRoleRenounceTargetTransactor.contract.Transact(opts, method, params...)
 10099  }
 10100  
 10101  // Call invokes the (constant) contract method with params as input values and
 10102  // sets the output to result. The result type might be a single field for simple
 10103  // returns, a slice of interfaces for anonymous returns and a struct for named
 10104  // returns.
 10105  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 10106  	return _PauserRoleRenounceTarget.Contract.contract.Call(opts, result, method, params...)
 10107  }
 10108  
 10109  // Transfer initiates a plain transaction to move funds to the contract, calling
 10110  // its default method if one is available.
 10111  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 10112  	return _PauserRoleRenounceTarget.Contract.contract.Transfer(opts)
 10113  }
 10114  
 10115  // Transact invokes the (paid) contract method with params as input values.
 10116  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 10117  	return _PauserRoleRenounceTarget.Contract.contract.Transact(opts, method, params...)
 10118  }
 10119  
 10120  // RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
 10121  //
 10122  // Solidity: function renouncePauser() returns()
 10123  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactor) RenouncePauser(opts *bind.TransactOpts) (*types.Transaction, error) {
 10124  	return _PauserRoleRenounceTarget.contract.Transact(opts, "renouncePauser")
 10125  }
 10126  
 10127  // RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
 10128  //
 10129  // Solidity: function renouncePauser() returns()
 10130  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetSession) RenouncePauser() (*types.Transaction, error) {
 10131  	return _PauserRoleRenounceTarget.Contract.RenouncePauser(&_PauserRoleRenounceTarget.TransactOpts)
 10132  }
 10133  
 10134  // RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d.
 10135  //
 10136  // Solidity: function renouncePauser() returns()
 10137  func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactorSession) RenouncePauser() (*types.Transaction, error) {
 10138  	return _PauserRoleRenounceTarget.Contract.RenouncePauser(&_PauserRoleRenounceTarget.TransactOpts)
 10139  }
 10140  
 10141  // ReentrancyGuardABI is the input ABI used to generate the binding from.
 10142  const ReentrancyGuardABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]"
 10143  
 10144  // ReentrancyGuard is an auto generated Go binding around an Ethereum contract.
 10145  type ReentrancyGuard struct {
 10146  	ReentrancyGuardCaller     // Read-only binding to the contract
 10147  	ReentrancyGuardTransactor // Write-only binding to the contract
 10148  	ReentrancyGuardFilterer   // Log filterer for contract events
 10149  }
 10150  
 10151  // ReentrancyGuardCaller is an auto generated read-only Go binding around an Ethereum contract.
 10152  type ReentrancyGuardCaller struct {
 10153  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 10154  }
 10155  
 10156  // ReentrancyGuardTransactor is an auto generated write-only Go binding around an Ethereum contract.
 10157  type ReentrancyGuardTransactor struct {
 10158  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 10159  }
 10160  
 10161  // ReentrancyGuardFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
 10162  type ReentrancyGuardFilterer struct {
 10163  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 10164  }
 10165  
 10166  // ReentrancyGuardSession is an auto generated Go binding around an Ethereum contract,
 10167  // with pre-set call and transact options.
 10168  type ReentrancyGuardSession struct {
 10169  	Contract     *ReentrancyGuard  // Generic contract binding to set the session for
 10170  	CallOpts     bind.CallOpts     // Call options to use throughout this session
 10171  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
 10172  }
 10173  
 10174  // ReentrancyGuardCallerSession is an auto generated read-only Go binding around an Ethereum contract,
 10175  // with pre-set call options.
 10176  type ReentrancyGuardCallerSession struct {
 10177  	Contract *ReentrancyGuardCaller // Generic contract caller binding to set the session for
 10178  	CallOpts bind.CallOpts          // Call options to use throughout this session
 10179  }
 10180  
 10181  // ReentrancyGuardTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
 10182  // with pre-set transact options.
 10183  type ReentrancyGuardTransactorSession struct {
 10184  	Contract     *ReentrancyGuardTransactor // Generic contract transactor binding to set the session for
 10185  	TransactOpts bind.TransactOpts          // Transaction auth options to use throughout this session
 10186  }
 10187  
 10188  // ReentrancyGuardRaw is an auto generated low-level Go binding around an Ethereum contract.
 10189  type ReentrancyGuardRaw struct {
 10190  	Contract *ReentrancyGuard // Generic contract binding to access the raw methods on
 10191  }
 10192  
 10193  // ReentrancyGuardCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
 10194  type ReentrancyGuardCallerRaw struct {
 10195  	Contract *ReentrancyGuardCaller // Generic read-only contract binding to access the raw methods on
 10196  }
 10197  
 10198  // ReentrancyGuardTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
 10199  type ReentrancyGuardTransactorRaw struct {
 10200  	Contract *ReentrancyGuardTransactor // Generic write-only contract binding to access the raw methods on
 10201  }
 10202  
 10203  // NewReentrancyGuard creates a new instance of ReentrancyGuard, bound to a specific deployed contract.
 10204  func NewReentrancyGuard(address common.Address, backend bind.ContractBackend) (*ReentrancyGuard, error) {
 10205  	contract, err := bindReentrancyGuard(address, backend, backend, backend)
 10206  	if err != nil {
 10207  		return nil, err
 10208  	}
 10209  	return &ReentrancyGuard{ReentrancyGuardCaller: ReentrancyGuardCaller{contract: contract}, ReentrancyGuardTransactor: ReentrancyGuardTransactor{contract: contract}, ReentrancyGuardFilterer: ReentrancyGuardFilterer{contract: contract}}, nil
 10210  }
 10211  
 10212  // NewReentrancyGuardCaller creates a new read-only instance of ReentrancyGuard, bound to a specific deployed contract.
 10213  func NewReentrancyGuardCaller(address common.Address, caller bind.ContractCaller) (*ReentrancyGuardCaller, error) {
 10214  	contract, err := bindReentrancyGuard(address, caller, nil, nil)
 10215  	if err != nil {
 10216  		return nil, err
 10217  	}
 10218  	return &ReentrancyGuardCaller{contract: contract}, nil
 10219  }
 10220  
 10221  // NewReentrancyGuardTransactor creates a new write-only instance of ReentrancyGuard, bound to a specific deployed contract.
 10222  func NewReentrancyGuardTransactor(address common.Address, transactor bind.ContractTransactor) (*ReentrancyGuardTransactor, error) {
 10223  	contract, err := bindReentrancyGuard(address, nil, transactor, nil)
 10224  	if err != nil {
 10225  		return nil, err
 10226  	}
 10227  	return &ReentrancyGuardTransactor{contract: contract}, nil
 10228  }
 10229  
 10230  // NewReentrancyGuardFilterer creates a new log filterer instance of ReentrancyGuard, bound to a specific deployed contract.
 10231  func NewReentrancyGuardFilterer(address common.Address, filterer bind.ContractFilterer) (*ReentrancyGuardFilterer, error) {
 10232  	contract, err := bindReentrancyGuard(address, nil, nil, filterer)
 10233  	if err != nil {
 10234  		return nil, err
 10235  	}
 10236  	return &ReentrancyGuardFilterer{contract: contract}, nil
 10237  }
 10238  
 10239  // bindReentrancyGuard binds a generic wrapper to an already deployed contract.
 10240  func bindReentrancyGuard(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 10241  	parsed, err := abi.JSON(strings.NewReader(ReentrancyGuardABI))
 10242  	if err != nil {
 10243  		return nil, err
 10244  	}
 10245  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 10246  }
 10247  
 10248  // Call invokes the (constant) contract method with params as input values and
 10249  // sets the output to result. The result type might be a single field for simple
 10250  // returns, a slice of interfaces for anonymous returns and a struct for named
 10251  // returns.
 10252  func (_ReentrancyGuard *ReentrancyGuardRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 10253  	return _ReentrancyGuard.Contract.ReentrancyGuardCaller.contract.Call(opts, result, method, params...)
 10254  }
 10255  
 10256  // Transfer initiates a plain transaction to move funds to the contract, calling
 10257  // its default method if one is available.
 10258  func (_ReentrancyGuard *ReentrancyGuardRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 10259  	return _ReentrancyGuard.Contract.ReentrancyGuardTransactor.contract.Transfer(opts)
 10260  }
 10261  
 10262  // Transact invokes the (paid) contract method with params as input values.
 10263  func (_ReentrancyGuard *ReentrancyGuardRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 10264  	return _ReentrancyGuard.Contract.ReentrancyGuardTransactor.contract.Transact(opts, method, params...)
 10265  }
 10266  
 10267  // Call invokes the (constant) contract method with params as input values and
 10268  // sets the output to result. The result type might be a single field for simple
 10269  // returns, a slice of interfaces for anonymous returns and a struct for named
 10270  // returns.
 10271  func (_ReentrancyGuard *ReentrancyGuardCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 10272  	return _ReentrancyGuard.Contract.contract.Call(opts, result, method, params...)
 10273  }
 10274  
 10275  // Transfer initiates a plain transaction to move funds to the contract, calling
 10276  // its default method if one is available.
 10277  func (_ReentrancyGuard *ReentrancyGuardTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 10278  	return _ReentrancyGuard.Contract.contract.Transfer(opts)
 10279  }
 10280  
 10281  // Transact invokes the (paid) contract method with params as input values.
 10282  func (_ReentrancyGuard *ReentrancyGuardTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 10283  	return _ReentrancyGuard.Contract.contract.Transact(opts, method, params...)
 10284  }
 10285  
 10286  // RolesABI is the input ABI used to generate the binding from.
 10287  const RolesABI = "[]"
 10288  
 10289  // RolesBin is the compiled bytecode used for deploying new contracts.
 10290  var RolesBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a72315820451a2112c879141f72bbe0ec00d853511a9d98646af7e3081d90a3d70270eb1564736f6c634300050c0032"
 10291  
 10292  // DeployRoles deploys a new Ethereum contract, binding an instance of Roles to it.
 10293  func DeployRoles(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Roles, error) {
 10294  	parsed, err := abi.JSON(strings.NewReader(RolesABI))
 10295  	if err != nil {
 10296  		return common.Address{}, nil, nil, err
 10297  	}
 10298  
 10299  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(RolesBin), backend)
 10300  	if err != nil {
 10301  		return common.Address{}, nil, nil, err
 10302  	}
 10303  	return address, tx, &Roles{RolesCaller: RolesCaller{contract: contract}, RolesTransactor: RolesTransactor{contract: contract}, RolesFilterer: RolesFilterer{contract: contract}}, nil
 10304  }
 10305  
 10306  // Roles is an auto generated Go binding around an Ethereum contract.
 10307  type Roles struct {
 10308  	RolesCaller     // Read-only binding to the contract
 10309  	RolesTransactor // Write-only binding to the contract
 10310  	RolesFilterer   // Log filterer for contract events
 10311  }
 10312  
 10313  // RolesCaller is an auto generated read-only Go binding around an Ethereum contract.
 10314  type RolesCaller struct {
 10315  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 10316  }
 10317  
 10318  // RolesTransactor is an auto generated write-only Go binding around an Ethereum contract.
 10319  type RolesTransactor struct {
 10320  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 10321  }
 10322  
 10323  // RolesFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
 10324  type RolesFilterer struct {
 10325  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 10326  }
 10327  
 10328  // RolesSession is an auto generated Go binding around an Ethereum contract,
 10329  // with pre-set call and transact options.
 10330  type RolesSession struct {
 10331  	Contract     *Roles            // Generic contract binding to set the session for
 10332  	CallOpts     bind.CallOpts     // Call options to use throughout this session
 10333  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
 10334  }
 10335  
 10336  // RolesCallerSession is an auto generated read-only Go binding around an Ethereum contract,
 10337  // with pre-set call options.
 10338  type RolesCallerSession struct {
 10339  	Contract *RolesCaller  // Generic contract caller binding to set the session for
 10340  	CallOpts bind.CallOpts // Call options to use throughout this session
 10341  }
 10342  
 10343  // RolesTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
 10344  // with pre-set transact options.
 10345  type RolesTransactorSession struct {
 10346  	Contract     *RolesTransactor  // Generic contract transactor binding to set the session for
 10347  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
 10348  }
 10349  
 10350  // RolesRaw is an auto generated low-level Go binding around an Ethereum contract.
 10351  type RolesRaw struct {
 10352  	Contract *Roles // Generic contract binding to access the raw methods on
 10353  }
 10354  
 10355  // RolesCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
 10356  type RolesCallerRaw struct {
 10357  	Contract *RolesCaller // Generic read-only contract binding to access the raw methods on
 10358  }
 10359  
 10360  // RolesTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
 10361  type RolesTransactorRaw struct {
 10362  	Contract *RolesTransactor // Generic write-only contract binding to access the raw methods on
 10363  }
 10364  
 10365  // NewRoles creates a new instance of Roles, bound to a specific deployed contract.
 10366  func NewRoles(address common.Address, backend bind.ContractBackend) (*Roles, error) {
 10367  	contract, err := bindRoles(address, backend, backend, backend)
 10368  	if err != nil {
 10369  		return nil, err
 10370  	}
 10371  	return &Roles{RolesCaller: RolesCaller{contract: contract}, RolesTransactor: RolesTransactor{contract: contract}, RolesFilterer: RolesFilterer{contract: contract}}, nil
 10372  }
 10373  
 10374  // NewRolesCaller creates a new read-only instance of Roles, bound to a specific deployed contract.
 10375  func NewRolesCaller(address common.Address, caller bind.ContractCaller) (*RolesCaller, error) {
 10376  	contract, err := bindRoles(address, caller, nil, nil)
 10377  	if err != nil {
 10378  		return nil, err
 10379  	}
 10380  	return &RolesCaller{contract: contract}, nil
 10381  }
 10382  
 10383  // NewRolesTransactor creates a new write-only instance of Roles, bound to a specific deployed contract.
 10384  func NewRolesTransactor(address common.Address, transactor bind.ContractTransactor) (*RolesTransactor, error) {
 10385  	contract, err := bindRoles(address, nil, transactor, nil)
 10386  	if err != nil {
 10387  		return nil, err
 10388  	}
 10389  	return &RolesTransactor{contract: contract}, nil
 10390  }
 10391  
 10392  // NewRolesFilterer creates a new log filterer instance of Roles, bound to a specific deployed contract.
 10393  func NewRolesFilterer(address common.Address, filterer bind.ContractFilterer) (*RolesFilterer, error) {
 10394  	contract, err := bindRoles(address, nil, nil, filterer)
 10395  	if err != nil {
 10396  		return nil, err
 10397  	}
 10398  	return &RolesFilterer{contract: contract}, nil
 10399  }
 10400  
 10401  // bindRoles binds a generic wrapper to an already deployed contract.
 10402  func bindRoles(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 10403  	parsed, err := abi.JSON(strings.NewReader(RolesABI))
 10404  	if err != nil {
 10405  		return nil, err
 10406  	}
 10407  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 10408  }
 10409  
 10410  // Call invokes the (constant) contract method with params as input values and
 10411  // sets the output to result. The result type might be a single field for simple
 10412  // returns, a slice of interfaces for anonymous returns and a struct for named
 10413  // returns.
 10414  func (_Roles *RolesRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 10415  	return _Roles.Contract.RolesCaller.contract.Call(opts, result, method, params...)
 10416  }
 10417  
 10418  // Transfer initiates a plain transaction to move funds to the contract, calling
 10419  // its default method if one is available.
 10420  func (_Roles *RolesRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 10421  	return _Roles.Contract.RolesTransactor.contract.Transfer(opts)
 10422  }
 10423  
 10424  // Transact invokes the (paid) contract method with params as input values.
 10425  func (_Roles *RolesRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 10426  	return _Roles.Contract.RolesTransactor.contract.Transact(opts, method, params...)
 10427  }
 10428  
 10429  // Call invokes the (constant) contract method with params as input values and
 10430  // sets the output to result. The result type might be a single field for simple
 10431  // returns, a slice of interfaces for anonymous returns and a struct for named
 10432  // returns.
 10433  func (_Roles *RolesCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 10434  	return _Roles.Contract.contract.Call(opts, result, method, params...)
 10435  }
 10436  
 10437  // Transfer initiates a plain transaction to move funds to the contract, calling
 10438  // its default method if one is available.
 10439  func (_Roles *RolesTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 10440  	return _Roles.Contract.contract.Transfer(opts)
 10441  }
 10442  
 10443  // Transact invokes the (paid) contract method with params as input values.
 10444  func (_Roles *RolesTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 10445  	return _Roles.Contract.contract.Transact(opts, method, params...)
 10446  }
 10447  
 10448  // RootChainIABI is the input ABI used to generate the binding from.
 10449  const RootChainIABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"currentFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isRootChain\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"forkNumber\",\"type\":\"uint256\"}],\"name\":\"lastEpoch\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"operator\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"
 10450  
 10451  // RootChainIFuncSigs maps the 4-byte function signature to its string representation.
 10452  var RootChainIFuncSigs = map[string]string{
 10453  	"183d2d1c": "currentFork()",
 10454  	"420bb4b8": "isRootChain()",
 10455  	"11e4c914": "lastEpoch(uint256)",
 10456  	"570ca735": "operator()",
 10457  }
 10458  
 10459  // RootChainI is an auto generated Go binding around an Ethereum contract.
 10460  type RootChainI struct {
 10461  	RootChainICaller     // Read-only binding to the contract
 10462  	RootChainITransactor // Write-only binding to the contract
 10463  	RootChainIFilterer   // Log filterer for contract events
 10464  }
 10465  
 10466  // RootChainICaller is an auto generated read-only Go binding around an Ethereum contract.
 10467  type RootChainICaller struct {
 10468  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 10469  }
 10470  
 10471  // RootChainITransactor is an auto generated write-only Go binding around an Ethereum contract.
 10472  type RootChainITransactor struct {
 10473  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 10474  }
 10475  
 10476  // RootChainIFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
 10477  type RootChainIFilterer struct {
 10478  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 10479  }
 10480  
 10481  // RootChainISession is an auto generated Go binding around an Ethereum contract,
 10482  // with pre-set call and transact options.
 10483  type RootChainISession struct {
 10484  	Contract     *RootChainI       // Generic contract binding to set the session for
 10485  	CallOpts     bind.CallOpts     // Call options to use throughout this session
 10486  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
 10487  }
 10488  
 10489  // RootChainICallerSession is an auto generated read-only Go binding around an Ethereum contract,
 10490  // with pre-set call options.
 10491  type RootChainICallerSession struct {
 10492  	Contract *RootChainICaller // Generic contract caller binding to set the session for
 10493  	CallOpts bind.CallOpts     // Call options to use throughout this session
 10494  }
 10495  
 10496  // RootChainITransactorSession is an auto generated write-only Go binding around an Ethereum contract,
 10497  // with pre-set transact options.
 10498  type RootChainITransactorSession struct {
 10499  	Contract     *RootChainITransactor // Generic contract transactor binding to set the session for
 10500  	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
 10501  }
 10502  
 10503  // RootChainIRaw is an auto generated low-level Go binding around an Ethereum contract.
 10504  type RootChainIRaw struct {
 10505  	Contract *RootChainI // Generic contract binding to access the raw methods on
 10506  }
 10507  
 10508  // RootChainICallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
 10509  type RootChainICallerRaw struct {
 10510  	Contract *RootChainICaller // Generic read-only contract binding to access the raw methods on
 10511  }
 10512  
 10513  // RootChainITransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
 10514  type RootChainITransactorRaw struct {
 10515  	Contract *RootChainITransactor // Generic write-only contract binding to access the raw methods on
 10516  }
 10517  
 10518  // NewRootChainI creates a new instance of RootChainI, bound to a specific deployed contract.
 10519  func NewRootChainI(address common.Address, backend bind.ContractBackend) (*RootChainI, error) {
 10520  	contract, err := bindRootChainI(address, backend, backend, backend)
 10521  	if err != nil {
 10522  		return nil, err
 10523  	}
 10524  	return &RootChainI{RootChainICaller: RootChainICaller{contract: contract}, RootChainITransactor: RootChainITransactor{contract: contract}, RootChainIFilterer: RootChainIFilterer{contract: contract}}, nil
 10525  }
 10526  
 10527  // NewRootChainICaller creates a new read-only instance of RootChainI, bound to a specific deployed contract.
 10528  func NewRootChainICaller(address common.Address, caller bind.ContractCaller) (*RootChainICaller, error) {
 10529  	contract, err := bindRootChainI(address, caller, nil, nil)
 10530  	if err != nil {
 10531  		return nil, err
 10532  	}
 10533  	return &RootChainICaller{contract: contract}, nil
 10534  }
 10535  
 10536  // NewRootChainITransactor creates a new write-only instance of RootChainI, bound to a specific deployed contract.
 10537  func NewRootChainITransactor(address common.Address, transactor bind.ContractTransactor) (*RootChainITransactor, error) {
 10538  	contract, err := bindRootChainI(address, nil, transactor, nil)
 10539  	if err != nil {
 10540  		return nil, err
 10541  	}
 10542  	return &RootChainITransactor{contract: contract}, nil
 10543  }
 10544  
 10545  // NewRootChainIFilterer creates a new log filterer instance of RootChainI, bound to a specific deployed contract.
 10546  func NewRootChainIFilterer(address common.Address, filterer bind.ContractFilterer) (*RootChainIFilterer, error) {
 10547  	contract, err := bindRootChainI(address, nil, nil, filterer)
 10548  	if err != nil {
 10549  		return nil, err
 10550  	}
 10551  	return &RootChainIFilterer{contract: contract}, nil
 10552  }
 10553  
 10554  // bindRootChainI binds a generic wrapper to an already deployed contract.
 10555  func bindRootChainI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 10556  	parsed, err := abi.JSON(strings.NewReader(RootChainIABI))
 10557  	if err != nil {
 10558  		return nil, err
 10559  	}
 10560  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 10561  }
 10562  
 10563  // Call invokes the (constant) contract method with params as input values and
 10564  // sets the output to result. The result type might be a single field for simple
 10565  // returns, a slice of interfaces for anonymous returns and a struct for named
 10566  // returns.
 10567  func (_RootChainI *RootChainIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 10568  	return _RootChainI.Contract.RootChainICaller.contract.Call(opts, result, method, params...)
 10569  }
 10570  
 10571  // Transfer initiates a plain transaction to move funds to the contract, calling
 10572  // its default method if one is available.
 10573  func (_RootChainI *RootChainIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 10574  	return _RootChainI.Contract.RootChainITransactor.contract.Transfer(opts)
 10575  }
 10576  
 10577  // Transact invokes the (paid) contract method with params as input values.
 10578  func (_RootChainI *RootChainIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 10579  	return _RootChainI.Contract.RootChainITransactor.contract.Transact(opts, method, params...)
 10580  }
 10581  
 10582  // Call invokes the (constant) contract method with params as input values and
 10583  // sets the output to result. The result type might be a single field for simple
 10584  // returns, a slice of interfaces for anonymous returns and a struct for named
 10585  // returns.
 10586  func (_RootChainI *RootChainICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 10587  	return _RootChainI.Contract.contract.Call(opts, result, method, params...)
 10588  }
 10589  
 10590  // Transfer initiates a plain transaction to move funds to the contract, calling
 10591  // its default method if one is available.
 10592  func (_RootChainI *RootChainITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 10593  	return _RootChainI.Contract.contract.Transfer(opts)
 10594  }
 10595  
 10596  // Transact invokes the (paid) contract method with params as input values.
 10597  func (_RootChainI *RootChainITransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 10598  	return _RootChainI.Contract.contract.Transact(opts, method, params...)
 10599  }
 10600  
 10601  // CurrentFork is a free data retrieval call binding the contract method 0x183d2d1c.
 10602  //
 10603  // Solidity: function currentFork() constant returns(uint256)
 10604  func (_RootChainI *RootChainICaller) CurrentFork(opts *bind.CallOpts) (*big.Int, error) {
 10605  	var (
 10606  		ret0 = new(*big.Int)
 10607  	)
 10608  	out := ret0
 10609  	err := _RootChainI.contract.Call(opts, out, "currentFork")
 10610  	return *ret0, err
 10611  }
 10612  
 10613  // CurrentFork is a free data retrieval call binding the contract method 0x183d2d1c.
 10614  //
 10615  // Solidity: function currentFork() constant returns(uint256)
 10616  func (_RootChainI *RootChainISession) CurrentFork() (*big.Int, error) {
 10617  	return _RootChainI.Contract.CurrentFork(&_RootChainI.CallOpts)
 10618  }
 10619  
 10620  // CurrentFork is a free data retrieval call binding the contract method 0x183d2d1c.
 10621  //
 10622  // Solidity: function currentFork() constant returns(uint256)
 10623  func (_RootChainI *RootChainICallerSession) CurrentFork() (*big.Int, error) {
 10624  	return _RootChainI.Contract.CurrentFork(&_RootChainI.CallOpts)
 10625  }
 10626  
 10627  // IsRootChain is a free data retrieval call binding the contract method 0x420bb4b8.
 10628  //
 10629  // Solidity: function isRootChain() constant returns(bool)
 10630  func (_RootChainI *RootChainICaller) IsRootChain(opts *bind.CallOpts) (bool, error) {
 10631  	var (
 10632  		ret0 = new(bool)
 10633  	)
 10634  	out := ret0
 10635  	err := _RootChainI.contract.Call(opts, out, "isRootChain")
 10636  	return *ret0, err
 10637  }
 10638  
 10639  // IsRootChain is a free data retrieval call binding the contract method 0x420bb4b8.
 10640  //
 10641  // Solidity: function isRootChain() constant returns(bool)
 10642  func (_RootChainI *RootChainISession) IsRootChain() (bool, error) {
 10643  	return _RootChainI.Contract.IsRootChain(&_RootChainI.CallOpts)
 10644  }
 10645  
 10646  // IsRootChain is a free data retrieval call binding the contract method 0x420bb4b8.
 10647  //
 10648  // Solidity: function isRootChain() constant returns(bool)
 10649  func (_RootChainI *RootChainICallerSession) IsRootChain() (bool, error) {
 10650  	return _RootChainI.Contract.IsRootChain(&_RootChainI.CallOpts)
 10651  }
 10652  
 10653  // LastEpoch is a free data retrieval call binding the contract method 0x11e4c914.
 10654  //
 10655  // Solidity: function lastEpoch(uint256 forkNumber) constant returns(uint256)
 10656  func (_RootChainI *RootChainICaller) LastEpoch(opts *bind.CallOpts, forkNumber *big.Int) (*big.Int, error) {
 10657  	var (
 10658  		ret0 = new(*big.Int)
 10659  	)
 10660  	out := ret0
 10661  	err := _RootChainI.contract.Call(opts, out, "lastEpoch", forkNumber)
 10662  	return *ret0, err
 10663  }
 10664  
 10665  // LastEpoch is a free data retrieval call binding the contract method 0x11e4c914.
 10666  //
 10667  // Solidity: function lastEpoch(uint256 forkNumber) constant returns(uint256)
 10668  func (_RootChainI *RootChainISession) LastEpoch(forkNumber *big.Int) (*big.Int, error) {
 10669  	return _RootChainI.Contract.LastEpoch(&_RootChainI.CallOpts, forkNumber)
 10670  }
 10671  
 10672  // LastEpoch is a free data retrieval call binding the contract method 0x11e4c914.
 10673  //
 10674  // Solidity: function lastEpoch(uint256 forkNumber) constant returns(uint256)
 10675  func (_RootChainI *RootChainICallerSession) LastEpoch(forkNumber *big.Int) (*big.Int, error) {
 10676  	return _RootChainI.Contract.LastEpoch(&_RootChainI.CallOpts, forkNumber)
 10677  }
 10678  
 10679  // Operator is a free data retrieval call binding the contract method 0x570ca735.
 10680  //
 10681  // Solidity: function operator() constant returns(address)
 10682  func (_RootChainI *RootChainICaller) Operator(opts *bind.CallOpts) (common.Address, error) {
 10683  	var (
 10684  		ret0 = new(common.Address)
 10685  	)
 10686  	out := ret0
 10687  	err := _RootChainI.contract.Call(opts, out, "operator")
 10688  	return *ret0, err
 10689  }
 10690  
 10691  // Operator is a free data retrieval call binding the contract method 0x570ca735.
 10692  //
 10693  // Solidity: function operator() constant returns(address)
 10694  func (_RootChainI *RootChainISession) Operator() (common.Address, error) {
 10695  	return _RootChainI.Contract.Operator(&_RootChainI.CallOpts)
 10696  }
 10697  
 10698  // Operator is a free data retrieval call binding the contract method 0x570ca735.
 10699  //
 10700  // Solidity: function operator() constant returns(address)
 10701  func (_RootChainI *RootChainICallerSession) Operator() (common.Address, error) {
 10702  	return _RootChainI.Contract.Operator(&_RootChainI.CallOpts)
 10703  }
 10704  
 10705  // RootChainRegistryIABI is the input ABI used to generate the binding from.
 10706  const RootChainRegistryIABI = "[{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"seigManager\",\"type\":\"address\"}],\"name\":\"deployCoinage\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"numRootChains\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"register\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"seigManager\",\"type\":\"address\"}],\"name\":\"registerAndDeployCoinage\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"rootchainByIndex\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"rootchains\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"unregister\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
 10707  
 10708  // RootChainRegistryIFuncSigs maps the 4-byte function signature to its string representation.
 10709  var RootChainRegistryIFuncSigs = map[string]string{
 10710  	"85108604": "deployCoinage(address,address)",
 10711  	"b2b604d0": "numRootChains()",
 10712  	"4420e486": "register(address)",
 10713  	"bcb1a71e": "registerAndDeployCoinage(address,address)",
 10714  	"821f602c": "rootchainByIndex(uint256)",
 10715  	"02a15299": "rootchains(address)",
 10716  	"2ec2c246": "unregister(address)",
 10717  }
 10718  
 10719  // RootChainRegistryI is an auto generated Go binding around an Ethereum contract.
 10720  type RootChainRegistryI struct {
 10721  	RootChainRegistryICaller     // Read-only binding to the contract
 10722  	RootChainRegistryITransactor // Write-only binding to the contract
 10723  	RootChainRegistryIFilterer   // Log filterer for contract events
 10724  }
 10725  
 10726  // RootChainRegistryICaller is an auto generated read-only Go binding around an Ethereum contract.
 10727  type RootChainRegistryICaller struct {
 10728  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 10729  }
 10730  
 10731  // RootChainRegistryITransactor is an auto generated write-only Go binding around an Ethereum contract.
 10732  type RootChainRegistryITransactor struct {
 10733  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 10734  }
 10735  
 10736  // RootChainRegistryIFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
 10737  type RootChainRegistryIFilterer struct {
 10738  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 10739  }
 10740  
 10741  // RootChainRegistryISession is an auto generated Go binding around an Ethereum contract,
 10742  // with pre-set call and transact options.
 10743  type RootChainRegistryISession struct {
 10744  	Contract     *RootChainRegistryI // Generic contract binding to set the session for
 10745  	CallOpts     bind.CallOpts       // Call options to use throughout this session
 10746  	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
 10747  }
 10748  
 10749  // RootChainRegistryICallerSession is an auto generated read-only Go binding around an Ethereum contract,
 10750  // with pre-set call options.
 10751  type RootChainRegistryICallerSession struct {
 10752  	Contract *RootChainRegistryICaller // Generic contract caller binding to set the session for
 10753  	CallOpts bind.CallOpts             // Call options to use throughout this session
 10754  }
 10755  
 10756  // RootChainRegistryITransactorSession is an auto generated write-only Go binding around an Ethereum contract,
 10757  // with pre-set transact options.
 10758  type RootChainRegistryITransactorSession struct {
 10759  	Contract     *RootChainRegistryITransactor // Generic contract transactor binding to set the session for
 10760  	TransactOpts bind.TransactOpts             // Transaction auth options to use throughout this session
 10761  }
 10762  
 10763  // RootChainRegistryIRaw is an auto generated low-level Go binding around an Ethereum contract.
 10764  type RootChainRegistryIRaw struct {
 10765  	Contract *RootChainRegistryI // Generic contract binding to access the raw methods on
 10766  }
 10767  
 10768  // RootChainRegistryICallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
 10769  type RootChainRegistryICallerRaw struct {
 10770  	Contract *RootChainRegistryICaller // Generic read-only contract binding to access the raw methods on
 10771  }
 10772  
 10773  // RootChainRegistryITransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
 10774  type RootChainRegistryITransactorRaw struct {
 10775  	Contract *RootChainRegistryITransactor // Generic write-only contract binding to access the raw methods on
 10776  }
 10777  
 10778  // NewRootChainRegistryI creates a new instance of RootChainRegistryI, bound to a specific deployed contract.
 10779  func NewRootChainRegistryI(address common.Address, backend bind.ContractBackend) (*RootChainRegistryI, error) {
 10780  	contract, err := bindRootChainRegistryI(address, backend, backend, backend)
 10781  	if err != nil {
 10782  		return nil, err
 10783  	}
 10784  	return &RootChainRegistryI{RootChainRegistryICaller: RootChainRegistryICaller{contract: contract}, RootChainRegistryITransactor: RootChainRegistryITransactor{contract: contract}, RootChainRegistryIFilterer: RootChainRegistryIFilterer{contract: contract}}, nil
 10785  }
 10786  
 10787  // NewRootChainRegistryICaller creates a new read-only instance of RootChainRegistryI, bound to a specific deployed contract.
 10788  func NewRootChainRegistryICaller(address common.Address, caller bind.ContractCaller) (*RootChainRegistryICaller, error) {
 10789  	contract, err := bindRootChainRegistryI(address, caller, nil, nil)
 10790  	if err != nil {
 10791  		return nil, err
 10792  	}
 10793  	return &RootChainRegistryICaller{contract: contract}, nil
 10794  }
 10795  
 10796  // NewRootChainRegistryITransactor creates a new write-only instance of RootChainRegistryI, bound to a specific deployed contract.
 10797  func NewRootChainRegistryITransactor(address common.Address, transactor bind.ContractTransactor) (*RootChainRegistryITransactor, error) {
 10798  	contract, err := bindRootChainRegistryI(address, nil, transactor, nil)
 10799  	if err != nil {
 10800  		return nil, err
 10801  	}
 10802  	return &RootChainRegistryITransactor{contract: contract}, nil
 10803  }
 10804  
 10805  // NewRootChainRegistryIFilterer creates a new log filterer instance of RootChainRegistryI, bound to a specific deployed contract.
 10806  func NewRootChainRegistryIFilterer(address common.Address, filterer bind.ContractFilterer) (*RootChainRegistryIFilterer, error) {
 10807  	contract, err := bindRootChainRegistryI(address, nil, nil, filterer)
 10808  	if err != nil {
 10809  		return nil, err
 10810  	}
 10811  	return &RootChainRegistryIFilterer{contract: contract}, nil
 10812  }
 10813  
 10814  // bindRootChainRegistryI binds a generic wrapper to an already deployed contract.
 10815  func bindRootChainRegistryI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 10816  	parsed, err := abi.JSON(strings.NewReader(RootChainRegistryIABI))
 10817  	if err != nil {
 10818  		return nil, err
 10819  	}
 10820  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 10821  }
 10822  
 10823  // Call invokes the (constant) contract method with params as input values and
 10824  // sets the output to result. The result type might be a single field for simple
 10825  // returns, a slice of interfaces for anonymous returns and a struct for named
 10826  // returns.
 10827  func (_RootChainRegistryI *RootChainRegistryIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 10828  	return _RootChainRegistryI.Contract.RootChainRegistryICaller.contract.Call(opts, result, method, params...)
 10829  }
 10830  
 10831  // Transfer initiates a plain transaction to move funds to the contract, calling
 10832  // its default method if one is available.
 10833  func (_RootChainRegistryI *RootChainRegistryIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 10834  	return _RootChainRegistryI.Contract.RootChainRegistryITransactor.contract.Transfer(opts)
 10835  }
 10836  
 10837  // Transact invokes the (paid) contract method with params as input values.
 10838  func (_RootChainRegistryI *RootChainRegistryIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 10839  	return _RootChainRegistryI.Contract.RootChainRegistryITransactor.contract.Transact(opts, method, params...)
 10840  }
 10841  
 10842  // Call invokes the (constant) contract method with params as input values and
 10843  // sets the output to result. The result type might be a single field for simple
 10844  // returns, a slice of interfaces for anonymous returns and a struct for named
 10845  // returns.
 10846  func (_RootChainRegistryI *RootChainRegistryICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 10847  	return _RootChainRegistryI.Contract.contract.Call(opts, result, method, params...)
 10848  }
 10849  
 10850  // Transfer initiates a plain transaction to move funds to the contract, calling
 10851  // its default method if one is available.
 10852  func (_RootChainRegistryI *RootChainRegistryITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 10853  	return _RootChainRegistryI.Contract.contract.Transfer(opts)
 10854  }
 10855  
 10856  // Transact invokes the (paid) contract method with params as input values.
 10857  func (_RootChainRegistryI *RootChainRegistryITransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 10858  	return _RootChainRegistryI.Contract.contract.Transact(opts, method, params...)
 10859  }
 10860  
 10861  // NumRootChains is a free data retrieval call binding the contract method 0xb2b604d0.
 10862  //
 10863  // Solidity: function numRootChains() constant returns(uint256)
 10864  func (_RootChainRegistryI *RootChainRegistryICaller) NumRootChains(opts *bind.CallOpts) (*big.Int, error) {
 10865  	var (
 10866  		ret0 = new(*big.Int)
 10867  	)
 10868  	out := ret0
 10869  	err := _RootChainRegistryI.contract.Call(opts, out, "numRootChains")
 10870  	return *ret0, err
 10871  }
 10872  
 10873  // NumRootChains is a free data retrieval call binding the contract method 0xb2b604d0.
 10874  //
 10875  // Solidity: function numRootChains() constant returns(uint256)
 10876  func (_RootChainRegistryI *RootChainRegistryISession) NumRootChains() (*big.Int, error) {
 10877  	return _RootChainRegistryI.Contract.NumRootChains(&_RootChainRegistryI.CallOpts)
 10878  }
 10879  
 10880  // NumRootChains is a free data retrieval call binding the contract method 0xb2b604d0.
 10881  //
 10882  // Solidity: function numRootChains() constant returns(uint256)
 10883  func (_RootChainRegistryI *RootChainRegistryICallerSession) NumRootChains() (*big.Int, error) {
 10884  	return _RootChainRegistryI.Contract.NumRootChains(&_RootChainRegistryI.CallOpts)
 10885  }
 10886  
 10887  // RootchainByIndex is a free data retrieval call binding the contract method 0x821f602c.
 10888  //
 10889  // Solidity: function rootchainByIndex(uint256 index) constant returns(address)
 10890  func (_RootChainRegistryI *RootChainRegistryICaller) RootchainByIndex(opts *bind.CallOpts, index *big.Int) (common.Address, error) {
 10891  	var (
 10892  		ret0 = new(common.Address)
 10893  	)
 10894  	out := ret0
 10895  	err := _RootChainRegistryI.contract.Call(opts, out, "rootchainByIndex", index)
 10896  	return *ret0, err
 10897  }
 10898  
 10899  // RootchainByIndex is a free data retrieval call binding the contract method 0x821f602c.
 10900  //
 10901  // Solidity: function rootchainByIndex(uint256 index) constant returns(address)
 10902  func (_RootChainRegistryI *RootChainRegistryISession) RootchainByIndex(index *big.Int) (common.Address, error) {
 10903  	return _RootChainRegistryI.Contract.RootchainByIndex(&_RootChainRegistryI.CallOpts, index)
 10904  }
 10905  
 10906  // RootchainByIndex is a free data retrieval call binding the contract method 0x821f602c.
 10907  //
 10908  // Solidity: function rootchainByIndex(uint256 index) constant returns(address)
 10909  func (_RootChainRegistryI *RootChainRegistryICallerSession) RootchainByIndex(index *big.Int) (common.Address, error) {
 10910  	return _RootChainRegistryI.Contract.RootchainByIndex(&_RootChainRegistryI.CallOpts, index)
 10911  }
 10912  
 10913  // Rootchains is a free data retrieval call binding the contract method 0x02a15299.
 10914  //
 10915  // Solidity: function rootchains(address rootchain) constant returns(bool)
 10916  func (_RootChainRegistryI *RootChainRegistryICaller) Rootchains(opts *bind.CallOpts, rootchain common.Address) (bool, error) {
 10917  	var (
 10918  		ret0 = new(bool)
 10919  	)
 10920  	out := ret0
 10921  	err := _RootChainRegistryI.contract.Call(opts, out, "rootchains", rootchain)
 10922  	return *ret0, err
 10923  }
 10924  
 10925  // Rootchains is a free data retrieval call binding the contract method 0x02a15299.
 10926  //
 10927  // Solidity: function rootchains(address rootchain) constant returns(bool)
 10928  func (_RootChainRegistryI *RootChainRegistryISession) Rootchains(rootchain common.Address) (bool, error) {
 10929  	return _RootChainRegistryI.Contract.Rootchains(&_RootChainRegistryI.CallOpts, rootchain)
 10930  }
 10931  
 10932  // Rootchains is a free data retrieval call binding the contract method 0x02a15299.
 10933  //
 10934  // Solidity: function rootchains(address rootchain) constant returns(bool)
 10935  func (_RootChainRegistryI *RootChainRegistryICallerSession) Rootchains(rootchain common.Address) (bool, error) {
 10936  	return _RootChainRegistryI.Contract.Rootchains(&_RootChainRegistryI.CallOpts, rootchain)
 10937  }
 10938  
 10939  // DeployCoinage is a paid mutator transaction binding the contract method 0x85108604.
 10940  //
 10941  // Solidity: function deployCoinage(address rootchain, address seigManager) returns(bool)
 10942  func (_RootChainRegistryI *RootChainRegistryITransactor) DeployCoinage(opts *bind.TransactOpts, rootchain common.Address, seigManager common.Address) (*types.Transaction, error) {
 10943  	return _RootChainRegistryI.contract.Transact(opts, "deployCoinage", rootchain, seigManager)
 10944  }
 10945  
 10946  // DeployCoinage is a paid mutator transaction binding the contract method 0x85108604.
 10947  //
 10948  // Solidity: function deployCoinage(address rootchain, address seigManager) returns(bool)
 10949  func (_RootChainRegistryI *RootChainRegistryISession) DeployCoinage(rootchain common.Address, seigManager common.Address) (*types.Transaction, error) {
 10950  	return _RootChainRegistryI.Contract.DeployCoinage(&_RootChainRegistryI.TransactOpts, rootchain, seigManager)
 10951  }
 10952  
 10953  // DeployCoinage is a paid mutator transaction binding the contract method 0x85108604.
 10954  //
 10955  // Solidity: function deployCoinage(address rootchain, address seigManager) returns(bool)
 10956  func (_RootChainRegistryI *RootChainRegistryITransactorSession) DeployCoinage(rootchain common.Address, seigManager common.Address) (*types.Transaction, error) {
 10957  	return _RootChainRegistryI.Contract.DeployCoinage(&_RootChainRegistryI.TransactOpts, rootchain, seigManager)
 10958  }
 10959  
 10960  // Register is a paid mutator transaction binding the contract method 0x4420e486.
 10961  //
 10962  // Solidity: function register(address rootchain) returns(bool)
 10963  func (_RootChainRegistryI *RootChainRegistryITransactor) Register(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) {
 10964  	return _RootChainRegistryI.contract.Transact(opts, "register", rootchain)
 10965  }
 10966  
 10967  // Register is a paid mutator transaction binding the contract method 0x4420e486.
 10968  //
 10969  // Solidity: function register(address rootchain) returns(bool)
 10970  func (_RootChainRegistryI *RootChainRegistryISession) Register(rootchain common.Address) (*types.Transaction, error) {
 10971  	return _RootChainRegistryI.Contract.Register(&_RootChainRegistryI.TransactOpts, rootchain)
 10972  }
 10973  
 10974  // Register is a paid mutator transaction binding the contract method 0x4420e486.
 10975  //
 10976  // Solidity: function register(address rootchain) returns(bool)
 10977  func (_RootChainRegistryI *RootChainRegistryITransactorSession) Register(rootchain common.Address) (*types.Transaction, error) {
 10978  	return _RootChainRegistryI.Contract.Register(&_RootChainRegistryI.TransactOpts, rootchain)
 10979  }
 10980  
 10981  // RegisterAndDeployCoinage is a paid mutator transaction binding the contract method 0xbcb1a71e.
 10982  //
 10983  // Solidity: function registerAndDeployCoinage(address rootchain, address seigManager) returns(bool)
 10984  func (_RootChainRegistryI *RootChainRegistryITransactor) RegisterAndDeployCoinage(opts *bind.TransactOpts, rootchain common.Address, seigManager common.Address) (*types.Transaction, error) {
 10985  	return _RootChainRegistryI.contract.Transact(opts, "registerAndDeployCoinage", rootchain, seigManager)
 10986  }
 10987  
 10988  // RegisterAndDeployCoinage is a paid mutator transaction binding the contract method 0xbcb1a71e.
 10989  //
 10990  // Solidity: function registerAndDeployCoinage(address rootchain, address seigManager) returns(bool)
 10991  func (_RootChainRegistryI *RootChainRegistryISession) RegisterAndDeployCoinage(rootchain common.Address, seigManager common.Address) (*types.Transaction, error) {
 10992  	return _RootChainRegistryI.Contract.RegisterAndDeployCoinage(&_RootChainRegistryI.TransactOpts, rootchain, seigManager)
 10993  }
 10994  
 10995  // RegisterAndDeployCoinage is a paid mutator transaction binding the contract method 0xbcb1a71e.
 10996  //
 10997  // Solidity: function registerAndDeployCoinage(address rootchain, address seigManager) returns(bool)
 10998  func (_RootChainRegistryI *RootChainRegistryITransactorSession) RegisterAndDeployCoinage(rootchain common.Address, seigManager common.Address) (*types.Transaction, error) {
 10999  	return _RootChainRegistryI.Contract.RegisterAndDeployCoinage(&_RootChainRegistryI.TransactOpts, rootchain, seigManager)
 11000  }
 11001  
 11002  // Unregister is a paid mutator transaction binding the contract method 0x2ec2c246.
 11003  //
 11004  // Solidity: function unregister(address rootchain) returns(bool)
 11005  func (_RootChainRegistryI *RootChainRegistryITransactor) Unregister(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) {
 11006  	return _RootChainRegistryI.contract.Transact(opts, "unregister", rootchain)
 11007  }
 11008  
 11009  // Unregister is a paid mutator transaction binding the contract method 0x2ec2c246.
 11010  //
 11011  // Solidity: function unregister(address rootchain) returns(bool)
 11012  func (_RootChainRegistryI *RootChainRegistryISession) Unregister(rootchain common.Address) (*types.Transaction, error) {
 11013  	return _RootChainRegistryI.Contract.Unregister(&_RootChainRegistryI.TransactOpts, rootchain)
 11014  }
 11015  
 11016  // Unregister is a paid mutator transaction binding the contract method 0x2ec2c246.
 11017  //
 11018  // Solidity: function unregister(address rootchain) returns(bool)
 11019  func (_RootChainRegistryI *RootChainRegistryITransactorSession) Unregister(rootchain common.Address) (*types.Transaction, error) {
 11020  	return _RootChainRegistryI.Contract.Unregister(&_RootChainRegistryI.TransactOpts, rootchain)
 11021  }
 11022  
 11023  // SafeERC20ABI is the input ABI used to generate the binding from.
 11024  const SafeERC20ABI = "[]"
 11025  
 11026  // SafeERC20Bin is the compiled bytecode used for deploying new contracts.
 11027  var SafeERC20Bin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582045a04cb654e4c37bcd57cef5b1e4313fd04e0fbb06c03b04321592cfa5eb149764736f6c634300050c0032"
 11028  
 11029  // DeploySafeERC20 deploys a new Ethereum contract, binding an instance of SafeERC20 to it.
 11030  func DeploySafeERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeERC20, error) {
 11031  	parsed, err := abi.JSON(strings.NewReader(SafeERC20ABI))
 11032  	if err != nil {
 11033  		return common.Address{}, nil, nil, err
 11034  	}
 11035  
 11036  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SafeERC20Bin), backend)
 11037  	if err != nil {
 11038  		return common.Address{}, nil, nil, err
 11039  	}
 11040  	return address, tx, &SafeERC20{SafeERC20Caller: SafeERC20Caller{contract: contract}, SafeERC20Transactor: SafeERC20Transactor{contract: contract}, SafeERC20Filterer: SafeERC20Filterer{contract: contract}}, nil
 11041  }
 11042  
 11043  // SafeERC20 is an auto generated Go binding around an Ethereum contract.
 11044  type SafeERC20 struct {
 11045  	SafeERC20Caller     // Read-only binding to the contract
 11046  	SafeERC20Transactor // Write-only binding to the contract
 11047  	SafeERC20Filterer   // Log filterer for contract events
 11048  }
 11049  
 11050  // SafeERC20Caller is an auto generated read-only Go binding around an Ethereum contract.
 11051  type SafeERC20Caller struct {
 11052  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 11053  }
 11054  
 11055  // SafeERC20Transactor is an auto generated write-only Go binding around an Ethereum contract.
 11056  type SafeERC20Transactor struct {
 11057  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 11058  }
 11059  
 11060  // SafeERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
 11061  type SafeERC20Filterer struct {
 11062  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 11063  }
 11064  
 11065  // SafeERC20Session is an auto generated Go binding around an Ethereum contract,
 11066  // with pre-set call and transact options.
 11067  type SafeERC20Session struct {
 11068  	Contract     *SafeERC20        // Generic contract binding to set the session for
 11069  	CallOpts     bind.CallOpts     // Call options to use throughout this session
 11070  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
 11071  }
 11072  
 11073  // SafeERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract,
 11074  // with pre-set call options.
 11075  type SafeERC20CallerSession struct {
 11076  	Contract *SafeERC20Caller // Generic contract caller binding to set the session for
 11077  	CallOpts bind.CallOpts    // Call options to use throughout this session
 11078  }
 11079  
 11080  // SafeERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
 11081  // with pre-set transact options.
 11082  type SafeERC20TransactorSession struct {
 11083  	Contract     *SafeERC20Transactor // Generic contract transactor binding to set the session for
 11084  	TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
 11085  }
 11086  
 11087  // SafeERC20Raw is an auto generated low-level Go binding around an Ethereum contract.
 11088  type SafeERC20Raw struct {
 11089  	Contract *SafeERC20 // Generic contract binding to access the raw methods on
 11090  }
 11091  
 11092  // SafeERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
 11093  type SafeERC20CallerRaw struct {
 11094  	Contract *SafeERC20Caller // Generic read-only contract binding to access the raw methods on
 11095  }
 11096  
 11097  // SafeERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
 11098  type SafeERC20TransactorRaw struct {
 11099  	Contract *SafeERC20Transactor // Generic write-only contract binding to access the raw methods on
 11100  }
 11101  
 11102  // NewSafeERC20 creates a new instance of SafeERC20, bound to a specific deployed contract.
 11103  func NewSafeERC20(address common.Address, backend bind.ContractBackend) (*SafeERC20, error) {
 11104  	contract, err := bindSafeERC20(address, backend, backend, backend)
 11105  	if err != nil {
 11106  		return nil, err
 11107  	}
 11108  	return &SafeERC20{SafeERC20Caller: SafeERC20Caller{contract: contract}, SafeERC20Transactor: SafeERC20Transactor{contract: contract}, SafeERC20Filterer: SafeERC20Filterer{contract: contract}}, nil
 11109  }
 11110  
 11111  // NewSafeERC20Caller creates a new read-only instance of SafeERC20, bound to a specific deployed contract.
 11112  func NewSafeERC20Caller(address common.Address, caller bind.ContractCaller) (*SafeERC20Caller, error) {
 11113  	contract, err := bindSafeERC20(address, caller, nil, nil)
 11114  	if err != nil {
 11115  		return nil, err
 11116  	}
 11117  	return &SafeERC20Caller{contract: contract}, nil
 11118  }
 11119  
 11120  // NewSafeERC20Transactor creates a new write-only instance of SafeERC20, bound to a specific deployed contract.
 11121  func NewSafeERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*SafeERC20Transactor, error) {
 11122  	contract, err := bindSafeERC20(address, nil, transactor, nil)
 11123  	if err != nil {
 11124  		return nil, err
 11125  	}
 11126  	return &SafeERC20Transactor{contract: contract}, nil
 11127  }
 11128  
 11129  // NewSafeERC20Filterer creates a new log filterer instance of SafeERC20, bound to a specific deployed contract.
 11130  func NewSafeERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*SafeERC20Filterer, error) {
 11131  	contract, err := bindSafeERC20(address, nil, nil, filterer)
 11132  	if err != nil {
 11133  		return nil, err
 11134  	}
 11135  	return &SafeERC20Filterer{contract: contract}, nil
 11136  }
 11137  
 11138  // bindSafeERC20 binds a generic wrapper to an already deployed contract.
 11139  func bindSafeERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 11140  	parsed, err := abi.JSON(strings.NewReader(SafeERC20ABI))
 11141  	if err != nil {
 11142  		return nil, err
 11143  	}
 11144  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 11145  }
 11146  
 11147  // Call invokes the (constant) contract method with params as input values and
 11148  // sets the output to result. The result type might be a single field for simple
 11149  // returns, a slice of interfaces for anonymous returns and a struct for named
 11150  // returns.
 11151  func (_SafeERC20 *SafeERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 11152  	return _SafeERC20.Contract.SafeERC20Caller.contract.Call(opts, result, method, params...)
 11153  }
 11154  
 11155  // Transfer initiates a plain transaction to move funds to the contract, calling
 11156  // its default method if one is available.
 11157  func (_SafeERC20 *SafeERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 11158  	return _SafeERC20.Contract.SafeERC20Transactor.contract.Transfer(opts)
 11159  }
 11160  
 11161  // Transact invokes the (paid) contract method with params as input values.
 11162  func (_SafeERC20 *SafeERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 11163  	return _SafeERC20.Contract.SafeERC20Transactor.contract.Transact(opts, method, params...)
 11164  }
 11165  
 11166  // Call invokes the (constant) contract method with params as input values and
 11167  // sets the output to result. The result type might be a single field for simple
 11168  // returns, a slice of interfaces for anonymous returns and a struct for named
 11169  // returns.
 11170  func (_SafeERC20 *SafeERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 11171  	return _SafeERC20.Contract.contract.Call(opts, result, method, params...)
 11172  }
 11173  
 11174  // Transfer initiates a plain transaction to move funds to the contract, calling
 11175  // its default method if one is available.
 11176  func (_SafeERC20 *SafeERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 11177  	return _SafeERC20.Contract.contract.Transfer(opts)
 11178  }
 11179  
 11180  // Transact invokes the (paid) contract method with params as input values.
 11181  func (_SafeERC20 *SafeERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 11182  	return _SafeERC20.Contract.contract.Transact(opts, method, params...)
 11183  }
 11184  
 11185  // SafeMathABI is the input ABI used to generate the binding from.
 11186  const SafeMathABI = "[]"
 11187  
 11188  // SafeMathBin is the compiled bytecode used for deploying new contracts.
 11189  var SafeMathBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582045f810ccb41cd151344ccf006ddfbe7c3c58a867d26e345c6576ae09178171dc64736f6c634300050c0032"
 11190  
 11191  // DeploySafeMath deploys a new Ethereum contract, binding an instance of SafeMath to it.
 11192  func DeploySafeMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeMath, error) {
 11193  	parsed, err := abi.JSON(strings.NewReader(SafeMathABI))
 11194  	if err != nil {
 11195  		return common.Address{}, nil, nil, err
 11196  	}
 11197  
 11198  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SafeMathBin), backend)
 11199  	if err != nil {
 11200  		return common.Address{}, nil, nil, err
 11201  	}
 11202  	return address, tx, &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil
 11203  }
 11204  
 11205  // SafeMath is an auto generated Go binding around an Ethereum contract.
 11206  type SafeMath struct {
 11207  	SafeMathCaller     // Read-only binding to the contract
 11208  	SafeMathTransactor // Write-only binding to the contract
 11209  	SafeMathFilterer   // Log filterer for contract events
 11210  }
 11211  
 11212  // SafeMathCaller is an auto generated read-only Go binding around an Ethereum contract.
 11213  type SafeMathCaller struct {
 11214  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 11215  }
 11216  
 11217  // SafeMathTransactor is an auto generated write-only Go binding around an Ethereum contract.
 11218  type SafeMathTransactor struct {
 11219  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 11220  }
 11221  
 11222  // SafeMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
 11223  type SafeMathFilterer struct {
 11224  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 11225  }
 11226  
 11227  // SafeMathSession is an auto generated Go binding around an Ethereum contract,
 11228  // with pre-set call and transact options.
 11229  type SafeMathSession struct {
 11230  	Contract     *SafeMath         // Generic contract binding to set the session for
 11231  	CallOpts     bind.CallOpts     // Call options to use throughout this session
 11232  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
 11233  }
 11234  
 11235  // SafeMathCallerSession is an auto generated read-only Go binding around an Ethereum contract,
 11236  // with pre-set call options.
 11237  type SafeMathCallerSession struct {
 11238  	Contract *SafeMathCaller // Generic contract caller binding to set the session for
 11239  	CallOpts bind.CallOpts   // Call options to use throughout this session
 11240  }
 11241  
 11242  // SafeMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
 11243  // with pre-set transact options.
 11244  type SafeMathTransactorSession struct {
 11245  	Contract     *SafeMathTransactor // Generic contract transactor binding to set the session for
 11246  	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
 11247  }
 11248  
 11249  // SafeMathRaw is an auto generated low-level Go binding around an Ethereum contract.
 11250  type SafeMathRaw struct {
 11251  	Contract *SafeMath // Generic contract binding to access the raw methods on
 11252  }
 11253  
 11254  // SafeMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
 11255  type SafeMathCallerRaw struct {
 11256  	Contract *SafeMathCaller // Generic read-only contract binding to access the raw methods on
 11257  }
 11258  
 11259  // SafeMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
 11260  type SafeMathTransactorRaw struct {
 11261  	Contract *SafeMathTransactor // Generic write-only contract binding to access the raw methods on
 11262  }
 11263  
 11264  // NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract.
 11265  func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error) {
 11266  	contract, err := bindSafeMath(address, backend, backend, backend)
 11267  	if err != nil {
 11268  		return nil, err
 11269  	}
 11270  	return &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil
 11271  }
 11272  
 11273  // NewSafeMathCaller creates a new read-only instance of SafeMath, bound to a specific deployed contract.
 11274  func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error) {
 11275  	contract, err := bindSafeMath(address, caller, nil, nil)
 11276  	if err != nil {
 11277  		return nil, err
 11278  	}
 11279  	return &SafeMathCaller{contract: contract}, nil
 11280  }
 11281  
 11282  // NewSafeMathTransactor creates a new write-only instance of SafeMath, bound to a specific deployed contract.
 11283  func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error) {
 11284  	contract, err := bindSafeMath(address, nil, transactor, nil)
 11285  	if err != nil {
 11286  		return nil, err
 11287  	}
 11288  	return &SafeMathTransactor{contract: contract}, nil
 11289  }
 11290  
 11291  // NewSafeMathFilterer creates a new log filterer instance of SafeMath, bound to a specific deployed contract.
 11292  func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error) {
 11293  	contract, err := bindSafeMath(address, nil, nil, filterer)
 11294  	if err != nil {
 11295  		return nil, err
 11296  	}
 11297  	return &SafeMathFilterer{contract: contract}, nil
 11298  }
 11299  
 11300  // bindSafeMath binds a generic wrapper to an already deployed contract.
 11301  func bindSafeMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 11302  	parsed, err := abi.JSON(strings.NewReader(SafeMathABI))
 11303  	if err != nil {
 11304  		return nil, err
 11305  	}
 11306  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 11307  }
 11308  
 11309  // Call invokes the (constant) contract method with params as input values and
 11310  // sets the output to result. The result type might be a single field for simple
 11311  // returns, a slice of interfaces for anonymous returns and a struct for named
 11312  // returns.
 11313  func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 11314  	return _SafeMath.Contract.SafeMathCaller.contract.Call(opts, result, method, params...)
 11315  }
 11316  
 11317  // Transfer initiates a plain transaction to move funds to the contract, calling
 11318  // its default method if one is available.
 11319  func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 11320  	return _SafeMath.Contract.SafeMathTransactor.contract.Transfer(opts)
 11321  }
 11322  
 11323  // Transact invokes the (paid) contract method with params as input values.
 11324  func (_SafeMath *SafeMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 11325  	return _SafeMath.Contract.SafeMathTransactor.contract.Transact(opts, method, params...)
 11326  }
 11327  
 11328  // Call invokes the (constant) contract method with params as input values and
 11329  // sets the output to result. The result type might be a single field for simple
 11330  // returns, a slice of interfaces for anonymous returns and a struct for named
 11331  // returns.
 11332  func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 11333  	return _SafeMath.Contract.contract.Call(opts, result, method, params...)
 11334  }
 11335  
 11336  // Transfer initiates a plain transaction to move funds to the contract, calling
 11337  // its default method if one is available.
 11338  func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 11339  	return _SafeMath.Contract.contract.Transfer(opts)
 11340  }
 11341  
 11342  // Transact invokes the (paid) contract method with params as input values.
 11343  func (_SafeMath *SafeMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 11344  	return _SafeMath.Contract.contract.Transact(opts, method, params...)
 11345  }
 11346  
 11347  // SeigManagerIABI is the input ABI used to generate the binding from.
 11348  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\"}]"
 11349  
 11350  // SeigManagerIFuncSigs maps the 4-byte function signature to its string representation.
 11351  var SeigManagerIFuncSigs = map[string]string{
 11352  	"8bf91dc4": "DEFAULT_FACTOR()",
 11353  	"48c8577e": "additionalTotBurnAmount(address,address,uint256)",
 11354  	"4c063c19": "coinages(address)",
 11355  	"7b056c1b": "commissionRates(address)",
 11356  	"833a774f": "deployCoinage(address)",
 11357  	"6c7ac9d8": "depositManager()",
 11358  	"c59f1046": "lastCommitBlock(address)",
 11359  	"f35c89e8": "lastSeigBlock()",
 11360  	"359c4d59": "onCommit()",
 11361  	"412c6d50": "onDeposit(address,address,uint256)",
 11362  	"4a393149": "onTransfer(address,address,uint256)",
 11363  	"f850ffaa": "onWithdraw(address,address,uint256)",
 11364  	"32053c99": "pausedBlock()",
 11365  	"3e832e1d": "powerton()",
 11366  	"7b103999": "registry()",
 11367  	"5f40a349": "seigPerBlock()",
 11368  	"4224ed66": "setCommissionRate(address,uint256,bool)",
 11369  	"ce4cb876": "stakeOf(address,address)",
 11370  	"cc48b947": "ton()",
 11371  	"a16d6aa7": "tot()",
 11372  	"fa9789c8": "uncomittedStakeOf(address,address)",
 11373  	"1cc47890": "unpausedBlock()",
 11374  	"8d62d949": "wton()",
 11375  }
 11376  
 11377  // SeigManagerI is an auto generated Go binding around an Ethereum contract.
 11378  type SeigManagerI struct {
 11379  	SeigManagerICaller     // Read-only binding to the contract
 11380  	SeigManagerITransactor // Write-only binding to the contract
 11381  	SeigManagerIFilterer   // Log filterer for contract events
 11382  }
 11383  
 11384  // SeigManagerICaller is an auto generated read-only Go binding around an Ethereum contract.
 11385  type SeigManagerICaller struct {
 11386  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 11387  }
 11388  
 11389  // SeigManagerITransactor is an auto generated write-only Go binding around an Ethereum contract.
 11390  type SeigManagerITransactor struct {
 11391  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 11392  }
 11393  
 11394  // SeigManagerIFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
 11395  type SeigManagerIFilterer struct {
 11396  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 11397  }
 11398  
 11399  // SeigManagerISession is an auto generated Go binding around an Ethereum contract,
 11400  // with pre-set call and transact options.
 11401  type SeigManagerISession struct {
 11402  	Contract     *SeigManagerI     // Generic contract binding to set the session for
 11403  	CallOpts     bind.CallOpts     // Call options to use throughout this session
 11404  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
 11405  }
 11406  
 11407  // SeigManagerICallerSession is an auto generated read-only Go binding around an Ethereum contract,
 11408  // with pre-set call options.
 11409  type SeigManagerICallerSession struct {
 11410  	Contract *SeigManagerICaller // Generic contract caller binding to set the session for
 11411  	CallOpts bind.CallOpts       // Call options to use throughout this session
 11412  }
 11413  
 11414  // SeigManagerITransactorSession is an auto generated write-only Go binding around an Ethereum contract,
 11415  // with pre-set transact options.
 11416  type SeigManagerITransactorSession struct {
 11417  	Contract     *SeigManagerITransactor // Generic contract transactor binding to set the session for
 11418  	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
 11419  }
 11420  
 11421  // SeigManagerIRaw is an auto generated low-level Go binding around an Ethereum contract.
 11422  type SeigManagerIRaw struct {
 11423  	Contract *SeigManagerI // Generic contract binding to access the raw methods on
 11424  }
 11425  
 11426  // SeigManagerICallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
 11427  type SeigManagerICallerRaw struct {
 11428  	Contract *SeigManagerICaller // Generic read-only contract binding to access the raw methods on
 11429  }
 11430  
 11431  // SeigManagerITransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
 11432  type SeigManagerITransactorRaw struct {
 11433  	Contract *SeigManagerITransactor // Generic write-only contract binding to access the raw methods on
 11434  }
 11435  
 11436  // NewSeigManagerI creates a new instance of SeigManagerI, bound to a specific deployed contract.
 11437  func NewSeigManagerI(address common.Address, backend bind.ContractBackend) (*SeigManagerI, error) {
 11438  	contract, err := bindSeigManagerI(address, backend, backend, backend)
 11439  	if err != nil {
 11440  		return nil, err
 11441  	}
 11442  	return &SeigManagerI{SeigManagerICaller: SeigManagerICaller{contract: contract}, SeigManagerITransactor: SeigManagerITransactor{contract: contract}, SeigManagerIFilterer: SeigManagerIFilterer{contract: contract}}, nil
 11443  }
 11444  
 11445  // NewSeigManagerICaller creates a new read-only instance of SeigManagerI, bound to a specific deployed contract.
 11446  func NewSeigManagerICaller(address common.Address, caller bind.ContractCaller) (*SeigManagerICaller, error) {
 11447  	contract, err := bindSeigManagerI(address, caller, nil, nil)
 11448  	if err != nil {
 11449  		return nil, err
 11450  	}
 11451  	return &SeigManagerICaller{contract: contract}, nil
 11452  }
 11453  
 11454  // NewSeigManagerITransactor creates a new write-only instance of SeigManagerI, bound to a specific deployed contract.
 11455  func NewSeigManagerITransactor(address common.Address, transactor bind.ContractTransactor) (*SeigManagerITransactor, error) {
 11456  	contract, err := bindSeigManagerI(address, nil, transactor, nil)
 11457  	if err != nil {
 11458  		return nil, err
 11459  	}
 11460  	return &SeigManagerITransactor{contract: contract}, nil
 11461  }
 11462  
 11463  // NewSeigManagerIFilterer creates a new log filterer instance of SeigManagerI, bound to a specific deployed contract.
 11464  func NewSeigManagerIFilterer(address common.Address, filterer bind.ContractFilterer) (*SeigManagerIFilterer, error) {
 11465  	contract, err := bindSeigManagerI(address, nil, nil, filterer)
 11466  	if err != nil {
 11467  		return nil, err
 11468  	}
 11469  	return &SeigManagerIFilterer{contract: contract}, nil
 11470  }
 11471  
 11472  // bindSeigManagerI binds a generic wrapper to an already deployed contract.
 11473  func bindSeigManagerI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 11474  	parsed, err := abi.JSON(strings.NewReader(SeigManagerIABI))
 11475  	if err != nil {
 11476  		return nil, err
 11477  	}
 11478  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 11479  }
 11480  
 11481  // Call invokes the (constant) contract method with params as input values and
 11482  // sets the output to result. The result type might be a single field for simple
 11483  // returns, a slice of interfaces for anonymous returns and a struct for named
 11484  // returns.
 11485  func (_SeigManagerI *SeigManagerIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 11486  	return _SeigManagerI.Contract.SeigManagerICaller.contract.Call(opts, result, method, params...)
 11487  }
 11488  
 11489  // Transfer initiates a plain transaction to move funds to the contract, calling
 11490  // its default method if one is available.
 11491  func (_SeigManagerI *SeigManagerIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 11492  	return _SeigManagerI.Contract.SeigManagerITransactor.contract.Transfer(opts)
 11493  }
 11494  
 11495  // Transact invokes the (paid) contract method with params as input values.
 11496  func (_SeigManagerI *SeigManagerIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 11497  	return _SeigManagerI.Contract.SeigManagerITransactor.contract.Transact(opts, method, params...)
 11498  }
 11499  
 11500  // Call invokes the (constant) contract method with params as input values and
 11501  // sets the output to result. The result type might be a single field for simple
 11502  // returns, a slice of interfaces for anonymous returns and a struct for named
 11503  // returns.
 11504  func (_SeigManagerI *SeigManagerICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 11505  	return _SeigManagerI.Contract.contract.Call(opts, result, method, params...)
 11506  }
 11507  
 11508  // Transfer initiates a plain transaction to move funds to the contract, calling
 11509  // its default method if one is available.
 11510  func (_SeigManagerI *SeigManagerITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 11511  	return _SeigManagerI.Contract.contract.Transfer(opts)
 11512  }
 11513  
 11514  // Transact invokes the (paid) contract method with params as input values.
 11515  func (_SeigManagerI *SeigManagerITransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 11516  	return _SeigManagerI.Contract.contract.Transact(opts, method, params...)
 11517  }
 11518  
 11519  // DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4.
 11520  //
 11521  // Solidity: function DEFAULT_FACTOR() constant returns(uint256)
 11522  func (_SeigManagerI *SeigManagerICaller) DEFAULTFACTOR(opts *bind.CallOpts) (*big.Int, error) {
 11523  	var (
 11524  		ret0 = new(*big.Int)
 11525  	)
 11526  	out := ret0
 11527  	err := _SeigManagerI.contract.Call(opts, out, "DEFAULT_FACTOR")
 11528  	return *ret0, err
 11529  }
 11530  
 11531  // DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4.
 11532  //
 11533  // Solidity: function DEFAULT_FACTOR() constant returns(uint256)
 11534  func (_SeigManagerI *SeigManagerISession) DEFAULTFACTOR() (*big.Int, error) {
 11535  	return _SeigManagerI.Contract.DEFAULTFACTOR(&_SeigManagerI.CallOpts)
 11536  }
 11537  
 11538  // DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4.
 11539  //
 11540  // Solidity: function DEFAULT_FACTOR() constant returns(uint256)
 11541  func (_SeigManagerI *SeigManagerICallerSession) DEFAULTFACTOR() (*big.Int, error) {
 11542  	return _SeigManagerI.Contract.DEFAULTFACTOR(&_SeigManagerI.CallOpts)
 11543  }
 11544  
 11545  // AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e.
 11546  //
 11547  // Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount)
 11548  func (_SeigManagerI *SeigManagerICaller) AdditionalTotBurnAmount(opts *bind.CallOpts, rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) {
 11549  	var (
 11550  		ret0 = new(*big.Int)
 11551  	)
 11552  	out := ret0
 11553  	err := _SeigManagerI.contract.Call(opts, out, "additionalTotBurnAmount", rootchain, account, amount)
 11554  	return *ret0, err
 11555  }
 11556  
 11557  // AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e.
 11558  //
 11559  // Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount)
 11560  func (_SeigManagerI *SeigManagerISession) AdditionalTotBurnAmount(rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) {
 11561  	return _SeigManagerI.Contract.AdditionalTotBurnAmount(&_SeigManagerI.CallOpts, rootchain, account, amount)
 11562  }
 11563  
 11564  // AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e.
 11565  //
 11566  // Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount)
 11567  func (_SeigManagerI *SeigManagerICallerSession) AdditionalTotBurnAmount(rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) {
 11568  	return _SeigManagerI.Contract.AdditionalTotBurnAmount(&_SeigManagerI.CallOpts, rootchain, account, amount)
 11569  }
 11570  
 11571  // Coinages is a free data retrieval call binding the contract method 0x4c063c19.
 11572  //
 11573  // Solidity: function coinages(address rootchain) constant returns(address)
 11574  func (_SeigManagerI *SeigManagerICaller) Coinages(opts *bind.CallOpts, rootchain common.Address) (common.Address, error) {
 11575  	var (
 11576  		ret0 = new(common.Address)
 11577  	)
 11578  	out := ret0
 11579  	err := _SeigManagerI.contract.Call(opts, out, "coinages", rootchain)
 11580  	return *ret0, err
 11581  }
 11582  
 11583  // Coinages is a free data retrieval call binding the contract method 0x4c063c19.
 11584  //
 11585  // Solidity: function coinages(address rootchain) constant returns(address)
 11586  func (_SeigManagerI *SeigManagerISession) Coinages(rootchain common.Address) (common.Address, error) {
 11587  	return _SeigManagerI.Contract.Coinages(&_SeigManagerI.CallOpts, rootchain)
 11588  }
 11589  
 11590  // Coinages is a free data retrieval call binding the contract method 0x4c063c19.
 11591  //
 11592  // Solidity: function coinages(address rootchain) constant returns(address)
 11593  func (_SeigManagerI *SeigManagerICallerSession) Coinages(rootchain common.Address) (common.Address, error) {
 11594  	return _SeigManagerI.Contract.Coinages(&_SeigManagerI.CallOpts, rootchain)
 11595  }
 11596  
 11597  // CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b.
 11598  //
 11599  // Solidity: function commissionRates(address rootchain) constant returns(uint256)
 11600  func (_SeigManagerI *SeigManagerICaller) CommissionRates(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
 11601  	var (
 11602  		ret0 = new(*big.Int)
 11603  	)
 11604  	out := ret0
 11605  	err := _SeigManagerI.contract.Call(opts, out, "commissionRates", rootchain)
 11606  	return *ret0, err
 11607  }
 11608  
 11609  // CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b.
 11610  //
 11611  // Solidity: function commissionRates(address rootchain) constant returns(uint256)
 11612  func (_SeigManagerI *SeigManagerISession) CommissionRates(rootchain common.Address) (*big.Int, error) {
 11613  	return _SeigManagerI.Contract.CommissionRates(&_SeigManagerI.CallOpts, rootchain)
 11614  }
 11615  
 11616  // CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b.
 11617  //
 11618  // Solidity: function commissionRates(address rootchain) constant returns(uint256)
 11619  func (_SeigManagerI *SeigManagerICallerSession) CommissionRates(rootchain common.Address) (*big.Int, error) {
 11620  	return _SeigManagerI.Contract.CommissionRates(&_SeigManagerI.CallOpts, rootchain)
 11621  }
 11622  
 11623  // DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8.
 11624  //
 11625  // Solidity: function depositManager() constant returns(address)
 11626  func (_SeigManagerI *SeigManagerICaller) DepositManager(opts *bind.CallOpts) (common.Address, error) {
 11627  	var (
 11628  		ret0 = new(common.Address)
 11629  	)
 11630  	out := ret0
 11631  	err := _SeigManagerI.contract.Call(opts, out, "depositManager")
 11632  	return *ret0, err
 11633  }
 11634  
 11635  // DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8.
 11636  //
 11637  // Solidity: function depositManager() constant returns(address)
 11638  func (_SeigManagerI *SeigManagerISession) DepositManager() (common.Address, error) {
 11639  	return _SeigManagerI.Contract.DepositManager(&_SeigManagerI.CallOpts)
 11640  }
 11641  
 11642  // DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8.
 11643  //
 11644  // Solidity: function depositManager() constant returns(address)
 11645  func (_SeigManagerI *SeigManagerICallerSession) DepositManager() (common.Address, error) {
 11646  	return _SeigManagerI.Contract.DepositManager(&_SeigManagerI.CallOpts)
 11647  }
 11648  
 11649  // LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046.
 11650  //
 11651  // Solidity: function lastCommitBlock(address rootchain) constant returns(uint256)
 11652  func (_SeigManagerI *SeigManagerICaller) LastCommitBlock(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) {
 11653  	var (
 11654  		ret0 = new(*big.Int)
 11655  	)
 11656  	out := ret0
 11657  	err := _SeigManagerI.contract.Call(opts, out, "lastCommitBlock", rootchain)
 11658  	return *ret0, err
 11659  }
 11660  
 11661  // LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046.
 11662  //
 11663  // Solidity: function lastCommitBlock(address rootchain) constant returns(uint256)
 11664  func (_SeigManagerI *SeigManagerISession) LastCommitBlock(rootchain common.Address) (*big.Int, error) {
 11665  	return _SeigManagerI.Contract.LastCommitBlock(&_SeigManagerI.CallOpts, rootchain)
 11666  }
 11667  
 11668  // LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046.
 11669  //
 11670  // Solidity: function lastCommitBlock(address rootchain) constant returns(uint256)
 11671  func (_SeigManagerI *SeigManagerICallerSession) LastCommitBlock(rootchain common.Address) (*big.Int, error) {
 11672  	return _SeigManagerI.Contract.LastCommitBlock(&_SeigManagerI.CallOpts, rootchain)
 11673  }
 11674  
 11675  // LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8.
 11676  //
 11677  // Solidity: function lastSeigBlock() constant returns(uint256)
 11678  func (_SeigManagerI *SeigManagerICaller) LastSeigBlock(opts *bind.CallOpts) (*big.Int, error) {
 11679  	var (
 11680  		ret0 = new(*big.Int)
 11681  	)
 11682  	out := ret0
 11683  	err := _SeigManagerI.contract.Call(opts, out, "lastSeigBlock")
 11684  	return *ret0, err
 11685  }
 11686  
 11687  // LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8.
 11688  //
 11689  // Solidity: function lastSeigBlock() constant returns(uint256)
 11690  func (_SeigManagerI *SeigManagerISession) LastSeigBlock() (*big.Int, error) {
 11691  	return _SeigManagerI.Contract.LastSeigBlock(&_SeigManagerI.CallOpts)
 11692  }
 11693  
 11694  // LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8.
 11695  //
 11696  // Solidity: function lastSeigBlock() constant returns(uint256)
 11697  func (_SeigManagerI *SeigManagerICallerSession) LastSeigBlock() (*big.Int, error) {
 11698  	return _SeigManagerI.Contract.LastSeigBlock(&_SeigManagerI.CallOpts)
 11699  }
 11700  
 11701  // PausedBlock is a free data retrieval call binding the contract method 0x32053c99.
 11702  //
 11703  // Solidity: function pausedBlock() constant returns(uint256)
 11704  func (_SeigManagerI *SeigManagerICaller) PausedBlock(opts *bind.CallOpts) (*big.Int, error) {
 11705  	var (
 11706  		ret0 = new(*big.Int)
 11707  	)
 11708  	out := ret0
 11709  	err := _SeigManagerI.contract.Call(opts, out, "pausedBlock")
 11710  	return *ret0, err
 11711  }
 11712  
 11713  // PausedBlock is a free data retrieval call binding the contract method 0x32053c99.
 11714  //
 11715  // Solidity: function pausedBlock() constant returns(uint256)
 11716  func (_SeigManagerI *SeigManagerISession) PausedBlock() (*big.Int, error) {
 11717  	return _SeigManagerI.Contract.PausedBlock(&_SeigManagerI.CallOpts)
 11718  }
 11719  
 11720  // PausedBlock is a free data retrieval call binding the contract method 0x32053c99.
 11721  //
 11722  // Solidity: function pausedBlock() constant returns(uint256)
 11723  func (_SeigManagerI *SeigManagerICallerSession) PausedBlock() (*big.Int, error) {
 11724  	return _SeigManagerI.Contract.PausedBlock(&_SeigManagerI.CallOpts)
 11725  }
 11726  
 11727  // Powerton is a free data retrieval call binding the contract method 0x3e832e1d.
 11728  //
 11729  // Solidity: function powerton() constant returns(address)
 11730  func (_SeigManagerI *SeigManagerICaller) Powerton(opts *bind.CallOpts) (common.Address, error) {
 11731  	var (
 11732  		ret0 = new(common.Address)
 11733  	)
 11734  	out := ret0
 11735  	err := _SeigManagerI.contract.Call(opts, out, "powerton")
 11736  	return *ret0, err
 11737  }
 11738  
 11739  // Powerton is a free data retrieval call binding the contract method 0x3e832e1d.
 11740  //
 11741  // Solidity: function powerton() constant returns(address)
 11742  func (_SeigManagerI *SeigManagerISession) Powerton() (common.Address, error) {
 11743  	return _SeigManagerI.Contract.Powerton(&_SeigManagerI.CallOpts)
 11744  }
 11745  
 11746  // Powerton is a free data retrieval call binding the contract method 0x3e832e1d.
 11747  //
 11748  // Solidity: function powerton() constant returns(address)
 11749  func (_SeigManagerI *SeigManagerICallerSession) Powerton() (common.Address, error) {
 11750  	return _SeigManagerI.Contract.Powerton(&_SeigManagerI.CallOpts)
 11751  }
 11752  
 11753  // Registry is a free data retrieval call binding the contract method 0x7b103999.
 11754  //
 11755  // Solidity: function registry() constant returns(address)
 11756  func (_SeigManagerI *SeigManagerICaller) Registry(opts *bind.CallOpts) (common.Address, error) {
 11757  	var (
 11758  		ret0 = new(common.Address)
 11759  	)
 11760  	out := ret0
 11761  	err := _SeigManagerI.contract.Call(opts, out, "registry")
 11762  	return *ret0, err
 11763  }
 11764  
 11765  // Registry is a free data retrieval call binding the contract method 0x7b103999.
 11766  //
 11767  // Solidity: function registry() constant returns(address)
 11768  func (_SeigManagerI *SeigManagerISession) Registry() (common.Address, error) {
 11769  	return _SeigManagerI.Contract.Registry(&_SeigManagerI.CallOpts)
 11770  }
 11771  
 11772  // Registry is a free data retrieval call binding the contract method 0x7b103999.
 11773  //
 11774  // Solidity: function registry() constant returns(address)
 11775  func (_SeigManagerI *SeigManagerICallerSession) Registry() (common.Address, error) {
 11776  	return _SeigManagerI.Contract.Registry(&_SeigManagerI.CallOpts)
 11777  }
 11778  
 11779  // SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
 11780  //
 11781  // Solidity: function seigPerBlock() constant returns(uint256)
 11782  func (_SeigManagerI *SeigManagerICaller) SeigPerBlock(opts *bind.CallOpts) (*big.Int, error) {
 11783  	var (
 11784  		ret0 = new(*big.Int)
 11785  	)
 11786  	out := ret0
 11787  	err := _SeigManagerI.contract.Call(opts, out, "seigPerBlock")
 11788  	return *ret0, err
 11789  }
 11790  
 11791  // SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
 11792  //
 11793  // Solidity: function seigPerBlock() constant returns(uint256)
 11794  func (_SeigManagerI *SeigManagerISession) SeigPerBlock() (*big.Int, error) {
 11795  	return _SeigManagerI.Contract.SeigPerBlock(&_SeigManagerI.CallOpts)
 11796  }
 11797  
 11798  // SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349.
 11799  //
 11800  // Solidity: function seigPerBlock() constant returns(uint256)
 11801  func (_SeigManagerI *SeigManagerICallerSession) SeigPerBlock() (*big.Int, error) {
 11802  	return _SeigManagerI.Contract.SeigPerBlock(&_SeigManagerI.CallOpts)
 11803  }
 11804  
 11805  // StakeOf is a free data retrieval call binding the contract method 0xce4cb876.
 11806  //
 11807  // Solidity: function stakeOf(address rootchain, address account) constant returns(uint256)
 11808  func (_SeigManagerI *SeigManagerICaller) StakeOf(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
 11809  	var (
 11810  		ret0 = new(*big.Int)
 11811  	)
 11812  	out := ret0
 11813  	err := _SeigManagerI.contract.Call(opts, out, "stakeOf", rootchain, account)
 11814  	return *ret0, err
 11815  }
 11816  
 11817  // StakeOf is a free data retrieval call binding the contract method 0xce4cb876.
 11818  //
 11819  // Solidity: function stakeOf(address rootchain, address account) constant returns(uint256)
 11820  func (_SeigManagerI *SeigManagerISession) StakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
 11821  	return _SeigManagerI.Contract.StakeOf(&_SeigManagerI.CallOpts, rootchain, account)
 11822  }
 11823  
 11824  // StakeOf is a free data retrieval call binding the contract method 0xce4cb876.
 11825  //
 11826  // Solidity: function stakeOf(address rootchain, address account) constant returns(uint256)
 11827  func (_SeigManagerI *SeigManagerICallerSession) StakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
 11828  	return _SeigManagerI.Contract.StakeOf(&_SeigManagerI.CallOpts, rootchain, account)
 11829  }
 11830  
 11831  // Ton is a free data retrieval call binding the contract method 0xcc48b947.
 11832  //
 11833  // Solidity: function ton() constant returns(address)
 11834  func (_SeigManagerI *SeigManagerICaller) Ton(opts *bind.CallOpts) (common.Address, error) {
 11835  	var (
 11836  		ret0 = new(common.Address)
 11837  	)
 11838  	out := ret0
 11839  	err := _SeigManagerI.contract.Call(opts, out, "ton")
 11840  	return *ret0, err
 11841  }
 11842  
 11843  // Ton is a free data retrieval call binding the contract method 0xcc48b947.
 11844  //
 11845  // Solidity: function ton() constant returns(address)
 11846  func (_SeigManagerI *SeigManagerISession) Ton() (common.Address, error) {
 11847  	return _SeigManagerI.Contract.Ton(&_SeigManagerI.CallOpts)
 11848  }
 11849  
 11850  // Ton is a free data retrieval call binding the contract method 0xcc48b947.
 11851  //
 11852  // Solidity: function ton() constant returns(address)
 11853  func (_SeigManagerI *SeigManagerICallerSession) Ton() (common.Address, error) {
 11854  	return _SeigManagerI.Contract.Ton(&_SeigManagerI.CallOpts)
 11855  }
 11856  
 11857  // Tot is a free data retrieval call binding the contract method 0xa16d6aa7.
 11858  //
 11859  // Solidity: function tot() constant returns(address)
 11860  func (_SeigManagerI *SeigManagerICaller) Tot(opts *bind.CallOpts) (common.Address, error) {
 11861  	var (
 11862  		ret0 = new(common.Address)
 11863  	)
 11864  	out := ret0
 11865  	err := _SeigManagerI.contract.Call(opts, out, "tot")
 11866  	return *ret0, err
 11867  }
 11868  
 11869  // Tot is a free data retrieval call binding the contract method 0xa16d6aa7.
 11870  //
 11871  // Solidity: function tot() constant returns(address)
 11872  func (_SeigManagerI *SeigManagerISession) Tot() (common.Address, error) {
 11873  	return _SeigManagerI.Contract.Tot(&_SeigManagerI.CallOpts)
 11874  }
 11875  
 11876  // Tot is a free data retrieval call binding the contract method 0xa16d6aa7.
 11877  //
 11878  // Solidity: function tot() constant returns(address)
 11879  func (_SeigManagerI *SeigManagerICallerSession) Tot() (common.Address, error) {
 11880  	return _SeigManagerI.Contract.Tot(&_SeigManagerI.CallOpts)
 11881  }
 11882  
 11883  // UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8.
 11884  //
 11885  // Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256)
 11886  func (_SeigManagerI *SeigManagerICaller) UncomittedStakeOf(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) {
 11887  	var (
 11888  		ret0 = new(*big.Int)
 11889  	)
 11890  	out := ret0
 11891  	err := _SeigManagerI.contract.Call(opts, out, "uncomittedStakeOf", rootchain, account)
 11892  	return *ret0, err
 11893  }
 11894  
 11895  // UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8.
 11896  //
 11897  // Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256)
 11898  func (_SeigManagerI *SeigManagerISession) UncomittedStakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
 11899  	return _SeigManagerI.Contract.UncomittedStakeOf(&_SeigManagerI.CallOpts, rootchain, account)
 11900  }
 11901  
 11902  // UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8.
 11903  //
 11904  // Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256)
 11905  func (_SeigManagerI *SeigManagerICallerSession) UncomittedStakeOf(rootchain common.Address, account common.Address) (*big.Int, error) {
 11906  	return _SeigManagerI.Contract.UncomittedStakeOf(&_SeigManagerI.CallOpts, rootchain, account)
 11907  }
 11908  
 11909  // UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890.
 11910  //
 11911  // Solidity: function unpausedBlock() constant returns(uint256)
 11912  func (_SeigManagerI *SeigManagerICaller) UnpausedBlock(opts *bind.CallOpts) (*big.Int, error) {
 11913  	var (
 11914  		ret0 = new(*big.Int)
 11915  	)
 11916  	out := ret0
 11917  	err := _SeigManagerI.contract.Call(opts, out, "unpausedBlock")
 11918  	return *ret0, err
 11919  }
 11920  
 11921  // UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890.
 11922  //
 11923  // Solidity: function unpausedBlock() constant returns(uint256)
 11924  func (_SeigManagerI *SeigManagerISession) UnpausedBlock() (*big.Int, error) {
 11925  	return _SeigManagerI.Contract.UnpausedBlock(&_SeigManagerI.CallOpts)
 11926  }
 11927  
 11928  // UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890.
 11929  //
 11930  // Solidity: function unpausedBlock() constant returns(uint256)
 11931  func (_SeigManagerI *SeigManagerICallerSession) UnpausedBlock() (*big.Int, error) {
 11932  	return _SeigManagerI.Contract.UnpausedBlock(&_SeigManagerI.CallOpts)
 11933  }
 11934  
 11935  // Wton is a free data retrieval call binding the contract method 0x8d62d949.
 11936  //
 11937  // Solidity: function wton() constant returns(address)
 11938  func (_SeigManagerI *SeigManagerICaller) Wton(opts *bind.CallOpts) (common.Address, error) {
 11939  	var (
 11940  		ret0 = new(common.Address)
 11941  	)
 11942  	out := ret0
 11943  	err := _SeigManagerI.contract.Call(opts, out, "wton")
 11944  	return *ret0, err
 11945  }
 11946  
 11947  // Wton is a free data retrieval call binding the contract method 0x8d62d949.
 11948  //
 11949  // Solidity: function wton() constant returns(address)
 11950  func (_SeigManagerI *SeigManagerISession) Wton() (common.Address, error) {
 11951  	return _SeigManagerI.Contract.Wton(&_SeigManagerI.CallOpts)
 11952  }
 11953  
 11954  // Wton is a free data retrieval call binding the contract method 0x8d62d949.
 11955  //
 11956  // Solidity: function wton() constant returns(address)
 11957  func (_SeigManagerI *SeigManagerICallerSession) Wton() (common.Address, error) {
 11958  	return _SeigManagerI.Contract.Wton(&_SeigManagerI.CallOpts)
 11959  }
 11960  
 11961  // DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f.
 11962  //
 11963  // Solidity: function deployCoinage(address rootchain) returns(bool)
 11964  func (_SeigManagerI *SeigManagerITransactor) DeployCoinage(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) {
 11965  	return _SeigManagerI.contract.Transact(opts, "deployCoinage", rootchain)
 11966  }
 11967  
 11968  // DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f.
 11969  //
 11970  // Solidity: function deployCoinage(address rootchain) returns(bool)
 11971  func (_SeigManagerI *SeigManagerISession) DeployCoinage(rootchain common.Address) (*types.Transaction, error) {
 11972  	return _SeigManagerI.Contract.DeployCoinage(&_SeigManagerI.TransactOpts, rootchain)
 11973  }
 11974  
 11975  // DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f.
 11976  //
 11977  // Solidity: function deployCoinage(address rootchain) returns(bool)
 11978  func (_SeigManagerI *SeigManagerITransactorSession) DeployCoinage(rootchain common.Address) (*types.Transaction, error) {
 11979  	return _SeigManagerI.Contract.DeployCoinage(&_SeigManagerI.TransactOpts, rootchain)
 11980  }
 11981  
 11982  // OnCommit is a paid mutator transaction binding the contract method 0x359c4d59.
 11983  //
 11984  // Solidity: function onCommit() returns(bool)
 11985  func (_SeigManagerI *SeigManagerITransactor) OnCommit(opts *bind.TransactOpts) (*types.Transaction, error) {
 11986  	return _SeigManagerI.contract.Transact(opts, "onCommit")
 11987  }
 11988  
 11989  // OnCommit is a paid mutator transaction binding the contract method 0x359c4d59.
 11990  //
 11991  // Solidity: function onCommit() returns(bool)
 11992  func (_SeigManagerI *SeigManagerISession) OnCommit() (*types.Transaction, error) {
 11993  	return _SeigManagerI.Contract.OnCommit(&_SeigManagerI.TransactOpts)
 11994  }
 11995  
 11996  // OnCommit is a paid mutator transaction binding the contract method 0x359c4d59.
 11997  //
 11998  // Solidity: function onCommit() returns(bool)
 11999  func (_SeigManagerI *SeigManagerITransactorSession) OnCommit() (*types.Transaction, error) {
 12000  	return _SeigManagerI.Contract.OnCommit(&_SeigManagerI.TransactOpts)
 12001  }
 12002  
 12003  // OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50.
 12004  //
 12005  // Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool)
 12006  func (_SeigManagerI *SeigManagerITransactor) OnDeposit(opts *bind.TransactOpts, rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
 12007  	return _SeigManagerI.contract.Transact(opts, "onDeposit", rootchain, account, amount)
 12008  }
 12009  
 12010  // OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50.
 12011  //
 12012  // Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool)
 12013  func (_SeigManagerI *SeigManagerISession) OnDeposit(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
 12014  	return _SeigManagerI.Contract.OnDeposit(&_SeigManagerI.TransactOpts, rootchain, account, amount)
 12015  }
 12016  
 12017  // OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50.
 12018  //
 12019  // Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool)
 12020  func (_SeigManagerI *SeigManagerITransactorSession) OnDeposit(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
 12021  	return _SeigManagerI.Contract.OnDeposit(&_SeigManagerI.TransactOpts, rootchain, account, amount)
 12022  }
 12023  
 12024  // OnTransfer is a paid mutator transaction binding the contract method 0x4a393149.
 12025  //
 12026  // Solidity: function onTransfer(address sender, address recipient, uint256 amount) returns(bool)
 12027  func (_SeigManagerI *SeigManagerITransactor) OnTransfer(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
 12028  	return _SeigManagerI.contract.Transact(opts, "onTransfer", sender, recipient, amount)
 12029  }
 12030  
 12031  // OnTransfer is a paid mutator transaction binding the contract method 0x4a393149.
 12032  //
 12033  // Solidity: function onTransfer(address sender, address recipient, uint256 amount) returns(bool)
 12034  func (_SeigManagerI *SeigManagerISession) OnTransfer(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
 12035  	return _SeigManagerI.Contract.OnTransfer(&_SeigManagerI.TransactOpts, sender, recipient, amount)
 12036  }
 12037  
 12038  // OnTransfer is a paid mutator transaction binding the contract method 0x4a393149.
 12039  //
 12040  // Solidity: function onTransfer(address sender, address recipient, uint256 amount) returns(bool)
 12041  func (_SeigManagerI *SeigManagerITransactorSession) OnTransfer(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
 12042  	return _SeigManagerI.Contract.OnTransfer(&_SeigManagerI.TransactOpts, sender, recipient, amount)
 12043  }
 12044  
 12045  // OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa.
 12046  //
 12047  // Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool)
 12048  func (_SeigManagerI *SeigManagerITransactor) OnWithdraw(opts *bind.TransactOpts, rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
 12049  	return _SeigManagerI.contract.Transact(opts, "onWithdraw", rootchain, account, amount)
 12050  }
 12051  
 12052  // OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa.
 12053  //
 12054  // Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool)
 12055  func (_SeigManagerI *SeigManagerISession) OnWithdraw(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
 12056  	return _SeigManagerI.Contract.OnWithdraw(&_SeigManagerI.TransactOpts, rootchain, account, amount)
 12057  }
 12058  
 12059  // OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa.
 12060  //
 12061  // Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool)
 12062  func (_SeigManagerI *SeigManagerITransactorSession) OnWithdraw(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) {
 12063  	return _SeigManagerI.Contract.OnWithdraw(&_SeigManagerI.TransactOpts, rootchain, account, amount)
 12064  }
 12065  
 12066  // SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66.
 12067  //
 12068  // Solidity: function setCommissionRate(address rootchain, uint256 commission, bool isCommissionRateNegative) returns(bool)
 12069  func (_SeigManagerI *SeigManagerITransactor) SetCommissionRate(opts *bind.TransactOpts, rootchain common.Address, commission *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) {
 12070  	return _SeigManagerI.contract.Transact(opts, "setCommissionRate", rootchain, commission, isCommissionRateNegative)
 12071  }
 12072  
 12073  // SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66.
 12074  //
 12075  // Solidity: function setCommissionRate(address rootchain, uint256 commission, bool isCommissionRateNegative) returns(bool)
 12076  func (_SeigManagerI *SeigManagerISession) SetCommissionRate(rootchain common.Address, commission *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) {
 12077  	return _SeigManagerI.Contract.SetCommissionRate(&_SeigManagerI.TransactOpts, rootchain, commission, isCommissionRateNegative)
 12078  }
 12079  
 12080  // SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66.
 12081  //
 12082  // Solidity: function setCommissionRate(address rootchain, uint256 commission, bool isCommissionRateNegative) returns(bool)
 12083  func (_SeigManagerI *SeigManagerITransactorSession) SetCommissionRate(rootchain common.Address, commission *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) {
 12084  	return _SeigManagerI.Contract.SetCommissionRate(&_SeigManagerI.TransactOpts, rootchain, commission, isCommissionRateNegative)
 12085  }
 12086  
 12087  // SeigTokenABI is the input ABI used to generate the binding from.
 12088  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\"}]"
 12089  
 12090  // SeigTokenFuncSigs maps the 4-byte function signature to its string representation.
 12091  var SeigTokenFuncSigs = map[string]string{
 12092  	"6cd28f9a": "INTERFACE_ID_ON_APPROVE()",
 12093  	"dd62ed3e": "allowance(address,address)",
 12094  	"095ea7b3": "approve(address,uint256)",
 12095  	"cae9ca51": "approveAndCall(address,uint256,bytes)",
 12096  	"70a08231": "balanceOf(address)",
 12097  	"a457c2d7": "decreaseAllowance(address,uint256)",
 12098  	"39509351": "increaseAllowance(address,uint256)",
 12099  	"8f32d59b": "isOwner()",
 12100  	"8da5cb5b": "owner()",
 12101  	"5f112c68": "renounceMinter(address)",
 12102  	"715018a6": "renounceOwnership()",
 12103  	"38bf3cfa": "renounceOwnership(address)",
 12104  	"41eb24bb": "renouncePauser(address)",
 12105  	"6fb7f558": "seigManager()",
 12106  	"7657f20a": "setSeigManager(address)",
 12107  	"18160ddd": "totalSupply()",
 12108  	"a9059cbb": "transfer(address,uint256)",
 12109  	"23b872dd": "transferFrom(address,address,uint256)",
 12110  	"f2fde38b": "transferOwnership(address)",
 12111  	"6d435421": "transferOwnership(address,address)",
 12112  }
 12113  
 12114  // SeigTokenBin is the compiled bytecode used for deploying new contracts.
 12115  var SeigTokenBin = "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"
 12116  
 12117  // DeploySeigToken deploys a new Ethereum contract, binding an instance of SeigToken to it.
 12118  func DeploySeigToken(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SeigToken, error) {
 12119  	parsed, err := abi.JSON(strings.NewReader(SeigTokenABI))
 12120  	if err != nil {
 12121  		return common.Address{}, nil, nil, err
 12122  	}
 12123  
 12124  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SeigTokenBin), backend)
 12125  	if err != nil {
 12126  		return common.Address{}, nil, nil, err
 12127  	}
 12128  	return address, tx, &SeigToken{SeigTokenCaller: SeigTokenCaller{contract: contract}, SeigTokenTransactor: SeigTokenTransactor{contract: contract}, SeigTokenFilterer: SeigTokenFilterer{contract: contract}}, nil
 12129  }
 12130  
 12131  // SeigToken is an auto generated Go binding around an Ethereum contract.
 12132  type SeigToken struct {
 12133  	SeigTokenCaller     // Read-only binding to the contract
 12134  	SeigTokenTransactor // Write-only binding to the contract
 12135  	SeigTokenFilterer   // Log filterer for contract events
 12136  }
 12137  
 12138  // SeigTokenCaller is an auto generated read-only Go binding around an Ethereum contract.
 12139  type SeigTokenCaller struct {
 12140  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 12141  }
 12142  
 12143  // SeigTokenTransactor is an auto generated write-only Go binding around an Ethereum contract.
 12144  type SeigTokenTransactor struct {
 12145  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 12146  }
 12147  
 12148  // SeigTokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
 12149  type SeigTokenFilterer struct {
 12150  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 12151  }
 12152  
 12153  // SeigTokenSession is an auto generated Go binding around an Ethereum contract,
 12154  // with pre-set call and transact options.
 12155  type SeigTokenSession struct {
 12156  	Contract     *SeigToken        // Generic contract binding to set the session for
 12157  	CallOpts     bind.CallOpts     // Call options to use throughout this session
 12158  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
 12159  }
 12160  
 12161  // SeigTokenCallerSession is an auto generated read-only Go binding around an Ethereum contract,
 12162  // with pre-set call options.
 12163  type SeigTokenCallerSession struct {
 12164  	Contract *SeigTokenCaller // Generic contract caller binding to set the session for
 12165  	CallOpts bind.CallOpts    // Call options to use throughout this session
 12166  }
 12167  
 12168  // SeigTokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
 12169  // with pre-set transact options.
 12170  type SeigTokenTransactorSession struct {
 12171  	Contract     *SeigTokenTransactor // Generic contract transactor binding to set the session for
 12172  	TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
 12173  }
 12174  
 12175  // SeigTokenRaw is an auto generated low-level Go binding around an Ethereum contract.
 12176  type SeigTokenRaw struct {
 12177  	Contract *SeigToken // Generic contract binding to access the raw methods on
 12178  }
 12179  
 12180  // SeigTokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
 12181  type SeigTokenCallerRaw struct {
 12182  	Contract *SeigTokenCaller // Generic read-only contract binding to access the raw methods on
 12183  }
 12184  
 12185  // SeigTokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
 12186  type SeigTokenTransactorRaw struct {
 12187  	Contract *SeigTokenTransactor // Generic write-only contract binding to access the raw methods on
 12188  }
 12189  
 12190  // NewSeigToken creates a new instance of SeigToken, bound to a specific deployed contract.
 12191  func NewSeigToken(address common.Address, backend bind.ContractBackend) (*SeigToken, error) {
 12192  	contract, err := bindSeigToken(address, backend, backend, backend)
 12193  	if err != nil {
 12194  		return nil, err
 12195  	}
 12196  	return &SeigToken{SeigTokenCaller: SeigTokenCaller{contract: contract}, SeigTokenTransactor: SeigTokenTransactor{contract: contract}, SeigTokenFilterer: SeigTokenFilterer{contract: contract}}, nil
 12197  }
 12198  
 12199  // NewSeigTokenCaller creates a new read-only instance of SeigToken, bound to a specific deployed contract.
 12200  func NewSeigTokenCaller(address common.Address, caller bind.ContractCaller) (*SeigTokenCaller, error) {
 12201  	contract, err := bindSeigToken(address, caller, nil, nil)
 12202  	if err != nil {
 12203  		return nil, err
 12204  	}
 12205  	return &SeigTokenCaller{contract: contract}, nil
 12206  }
 12207  
 12208  // NewSeigTokenTransactor creates a new write-only instance of SeigToken, bound to a specific deployed contract.
 12209  func NewSeigTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*SeigTokenTransactor, error) {
 12210  	contract, err := bindSeigToken(address, nil, transactor, nil)
 12211  	if err != nil {
 12212  		return nil, err
 12213  	}
 12214  	return &SeigTokenTransactor{contract: contract}, nil
 12215  }
 12216  
 12217  // NewSeigTokenFilterer creates a new log filterer instance of SeigToken, bound to a specific deployed contract.
 12218  func NewSeigTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*SeigTokenFilterer, error) {
 12219  	contract, err := bindSeigToken(address, nil, nil, filterer)
 12220  	if err != nil {
 12221  		return nil, err
 12222  	}
 12223  	return &SeigTokenFilterer{contract: contract}, nil
 12224  }
 12225  
 12226  // bindSeigToken binds a generic wrapper to an already deployed contract.
 12227  func bindSeigToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 12228  	parsed, err := abi.JSON(strings.NewReader(SeigTokenABI))
 12229  	if err != nil {
 12230  		return nil, err
 12231  	}
 12232  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 12233  }
 12234  
 12235  // Call invokes the (constant) contract method with params as input values and
 12236  // sets the output to result. The result type might be a single field for simple
 12237  // returns, a slice of interfaces for anonymous returns and a struct for named
 12238  // returns.
 12239  func (_SeigToken *SeigTokenRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 12240  	return _SeigToken.Contract.SeigTokenCaller.contract.Call(opts, result, method, params...)
 12241  }
 12242  
 12243  // Transfer initiates a plain transaction to move funds to the contract, calling
 12244  // its default method if one is available.
 12245  func (_SeigToken *SeigTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 12246  	return _SeigToken.Contract.SeigTokenTransactor.contract.Transfer(opts)
 12247  }
 12248  
 12249  // Transact invokes the (paid) contract method with params as input values.
 12250  func (_SeigToken *SeigTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 12251  	return _SeigToken.Contract.SeigTokenTransactor.contract.Transact(opts, method, params...)
 12252  }
 12253  
 12254  // Call invokes the (constant) contract method with params as input values and
 12255  // sets the output to result. The result type might be a single field for simple
 12256  // returns, a slice of interfaces for anonymous returns and a struct for named
 12257  // returns.
 12258  func (_SeigToken *SeigTokenCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 12259  	return _SeigToken.Contract.contract.Call(opts, result, method, params...)
 12260  }
 12261  
 12262  // Transfer initiates a plain transaction to move funds to the contract, calling
 12263  // its default method if one is available.
 12264  func (_SeigToken *SeigTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 12265  	return _SeigToken.Contract.contract.Transfer(opts)
 12266  }
 12267  
 12268  // Transact invokes the (paid) contract method with params as input values.
 12269  func (_SeigToken *SeigTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 12270  	return _SeigToken.Contract.contract.Transact(opts, method, params...)
 12271  }
 12272  
 12273  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
 12274  //
 12275  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
 12276  func (_SeigToken *SeigTokenCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) {
 12277  	var (
 12278  		ret0 = new([4]byte)
 12279  	)
 12280  	out := ret0
 12281  	err := _SeigToken.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE")
 12282  	return *ret0, err
 12283  }
 12284  
 12285  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
 12286  //
 12287  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
 12288  func (_SeigToken *SeigTokenSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
 12289  	return _SeigToken.Contract.INTERFACEIDONAPPROVE(&_SeigToken.CallOpts)
 12290  }
 12291  
 12292  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
 12293  //
 12294  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
 12295  func (_SeigToken *SeigTokenCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
 12296  	return _SeigToken.Contract.INTERFACEIDONAPPROVE(&_SeigToken.CallOpts)
 12297  }
 12298  
 12299  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
 12300  //
 12301  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
 12302  func (_SeigToken *SeigTokenCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
 12303  	var (
 12304  		ret0 = new(*big.Int)
 12305  	)
 12306  	out := ret0
 12307  	err := _SeigToken.contract.Call(opts, out, "allowance", owner, spender)
 12308  	return *ret0, err
 12309  }
 12310  
 12311  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
 12312  //
 12313  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
 12314  func (_SeigToken *SeigTokenSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
 12315  	return _SeigToken.Contract.Allowance(&_SeigToken.CallOpts, owner, spender)
 12316  }
 12317  
 12318  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
 12319  //
 12320  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
 12321  func (_SeigToken *SeigTokenCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
 12322  	return _SeigToken.Contract.Allowance(&_SeigToken.CallOpts, owner, spender)
 12323  }
 12324  
 12325  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
 12326  //
 12327  // Solidity: function balanceOf(address account) constant returns(uint256)
 12328  func (_SeigToken *SeigTokenCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
 12329  	var (
 12330  		ret0 = new(*big.Int)
 12331  	)
 12332  	out := ret0
 12333  	err := _SeigToken.contract.Call(opts, out, "balanceOf", account)
 12334  	return *ret0, err
 12335  }
 12336  
 12337  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
 12338  //
 12339  // Solidity: function balanceOf(address account) constant returns(uint256)
 12340  func (_SeigToken *SeigTokenSession) BalanceOf(account common.Address) (*big.Int, error) {
 12341  	return _SeigToken.Contract.BalanceOf(&_SeigToken.CallOpts, account)
 12342  }
 12343  
 12344  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
 12345  //
 12346  // Solidity: function balanceOf(address account) constant returns(uint256)
 12347  func (_SeigToken *SeigTokenCallerSession) BalanceOf(account common.Address) (*big.Int, error) {
 12348  	return _SeigToken.Contract.BalanceOf(&_SeigToken.CallOpts, account)
 12349  }
 12350  
 12351  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
 12352  //
 12353  // Solidity: function isOwner() constant returns(bool)
 12354  func (_SeigToken *SeigTokenCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
 12355  	var (
 12356  		ret0 = new(bool)
 12357  	)
 12358  	out := ret0
 12359  	err := _SeigToken.contract.Call(opts, out, "isOwner")
 12360  	return *ret0, err
 12361  }
 12362  
 12363  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
 12364  //
 12365  // Solidity: function isOwner() constant returns(bool)
 12366  func (_SeigToken *SeigTokenSession) IsOwner() (bool, error) {
 12367  	return _SeigToken.Contract.IsOwner(&_SeigToken.CallOpts)
 12368  }
 12369  
 12370  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
 12371  //
 12372  // Solidity: function isOwner() constant returns(bool)
 12373  func (_SeigToken *SeigTokenCallerSession) IsOwner() (bool, error) {
 12374  	return _SeigToken.Contract.IsOwner(&_SeigToken.CallOpts)
 12375  }
 12376  
 12377  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
 12378  //
 12379  // Solidity: function owner() constant returns(address)
 12380  func (_SeigToken *SeigTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
 12381  	var (
 12382  		ret0 = new(common.Address)
 12383  	)
 12384  	out := ret0
 12385  	err := _SeigToken.contract.Call(opts, out, "owner")
 12386  	return *ret0, err
 12387  }
 12388  
 12389  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
 12390  //
 12391  // Solidity: function owner() constant returns(address)
 12392  func (_SeigToken *SeigTokenSession) Owner() (common.Address, error) {
 12393  	return _SeigToken.Contract.Owner(&_SeigToken.CallOpts)
 12394  }
 12395  
 12396  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
 12397  //
 12398  // Solidity: function owner() constant returns(address)
 12399  func (_SeigToken *SeigTokenCallerSession) Owner() (common.Address, error) {
 12400  	return _SeigToken.Contract.Owner(&_SeigToken.CallOpts)
 12401  }
 12402  
 12403  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
 12404  //
 12405  // Solidity: function seigManager() constant returns(address)
 12406  func (_SeigToken *SeigTokenCaller) SeigManager(opts *bind.CallOpts) (common.Address, error) {
 12407  	var (
 12408  		ret0 = new(common.Address)
 12409  	)
 12410  	out := ret0
 12411  	err := _SeigToken.contract.Call(opts, out, "seigManager")
 12412  	return *ret0, err
 12413  }
 12414  
 12415  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
 12416  //
 12417  // Solidity: function seigManager() constant returns(address)
 12418  func (_SeigToken *SeigTokenSession) SeigManager() (common.Address, error) {
 12419  	return _SeigToken.Contract.SeigManager(&_SeigToken.CallOpts)
 12420  }
 12421  
 12422  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
 12423  //
 12424  // Solidity: function seigManager() constant returns(address)
 12425  func (_SeigToken *SeigTokenCallerSession) SeigManager() (common.Address, error) {
 12426  	return _SeigToken.Contract.SeigManager(&_SeigToken.CallOpts)
 12427  }
 12428  
 12429  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
 12430  //
 12431  // Solidity: function totalSupply() constant returns(uint256)
 12432  func (_SeigToken *SeigTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
 12433  	var (
 12434  		ret0 = new(*big.Int)
 12435  	)
 12436  	out := ret0
 12437  	err := _SeigToken.contract.Call(opts, out, "totalSupply")
 12438  	return *ret0, err
 12439  }
 12440  
 12441  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
 12442  //
 12443  // Solidity: function totalSupply() constant returns(uint256)
 12444  func (_SeigToken *SeigTokenSession) TotalSupply() (*big.Int, error) {
 12445  	return _SeigToken.Contract.TotalSupply(&_SeigToken.CallOpts)
 12446  }
 12447  
 12448  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
 12449  //
 12450  // Solidity: function totalSupply() constant returns(uint256)
 12451  func (_SeigToken *SeigTokenCallerSession) TotalSupply() (*big.Int, error) {
 12452  	return _SeigToken.Contract.TotalSupply(&_SeigToken.CallOpts)
 12453  }
 12454  
 12455  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
 12456  //
 12457  // Solidity: function approve(address spender, uint256 amount) returns(bool)
 12458  func (_SeigToken *SeigTokenTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
 12459  	return _SeigToken.contract.Transact(opts, "approve", spender, amount)
 12460  }
 12461  
 12462  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
 12463  //
 12464  // Solidity: function approve(address spender, uint256 amount) returns(bool)
 12465  func (_SeigToken *SeigTokenSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
 12466  	return _SeigToken.Contract.Approve(&_SeigToken.TransactOpts, spender, amount)
 12467  }
 12468  
 12469  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
 12470  //
 12471  // Solidity: function approve(address spender, uint256 amount) returns(bool)
 12472  func (_SeigToken *SeigTokenTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
 12473  	return _SeigToken.Contract.Approve(&_SeigToken.TransactOpts, spender, amount)
 12474  }
 12475  
 12476  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
 12477  //
 12478  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
 12479  func (_SeigToken *SeigTokenTransactor) ApproveAndCall(opts *bind.TransactOpts, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
 12480  	return _SeigToken.contract.Transact(opts, "approveAndCall", spender, amount, data)
 12481  }
 12482  
 12483  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
 12484  //
 12485  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
 12486  func (_SeigToken *SeigTokenSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
 12487  	return _SeigToken.Contract.ApproveAndCall(&_SeigToken.TransactOpts, spender, amount, data)
 12488  }
 12489  
 12490  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
 12491  //
 12492  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
 12493  func (_SeigToken *SeigTokenTransactorSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
 12494  	return _SeigToken.Contract.ApproveAndCall(&_SeigToken.TransactOpts, spender, amount, data)
 12495  }
 12496  
 12497  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
 12498  //
 12499  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
 12500  func (_SeigToken *SeigTokenTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
 12501  	return _SeigToken.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
 12502  }
 12503  
 12504  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
 12505  //
 12506  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
 12507  func (_SeigToken *SeigTokenSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
 12508  	return _SeigToken.Contract.DecreaseAllowance(&_SeigToken.TransactOpts, spender, subtractedValue)
 12509  }
 12510  
 12511  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
 12512  //
 12513  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
 12514  func (_SeigToken *SeigTokenTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
 12515  	return _SeigToken.Contract.DecreaseAllowance(&_SeigToken.TransactOpts, spender, subtractedValue)
 12516  }
 12517  
 12518  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
 12519  //
 12520  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
 12521  func (_SeigToken *SeigTokenTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
 12522  	return _SeigToken.contract.Transact(opts, "increaseAllowance", spender, addedValue)
 12523  }
 12524  
 12525  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
 12526  //
 12527  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
 12528  func (_SeigToken *SeigTokenSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
 12529  	return _SeigToken.Contract.IncreaseAllowance(&_SeigToken.TransactOpts, spender, addedValue)
 12530  }
 12531  
 12532  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
 12533  //
 12534  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
 12535  func (_SeigToken *SeigTokenTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
 12536  	return _SeigToken.Contract.IncreaseAllowance(&_SeigToken.TransactOpts, spender, addedValue)
 12537  }
 12538  
 12539  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
 12540  //
 12541  // Solidity: function renounceMinter(address target) returns()
 12542  func (_SeigToken *SeigTokenTransactor) RenounceMinter(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
 12543  	return _SeigToken.contract.Transact(opts, "renounceMinter", target)
 12544  }
 12545  
 12546  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
 12547  //
 12548  // Solidity: function renounceMinter(address target) returns()
 12549  func (_SeigToken *SeigTokenSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
 12550  	return _SeigToken.Contract.RenounceMinter(&_SeigToken.TransactOpts, target)
 12551  }
 12552  
 12553  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
 12554  //
 12555  // Solidity: function renounceMinter(address target) returns()
 12556  func (_SeigToken *SeigTokenTransactorSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
 12557  	return _SeigToken.Contract.RenounceMinter(&_SeigToken.TransactOpts, target)
 12558  }
 12559  
 12560  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
 12561  //
 12562  // Solidity: function renounceOwnership(address target) returns()
 12563  func (_SeigToken *SeigTokenTransactor) RenounceOwnership(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
 12564  	return _SeigToken.contract.Transact(opts, "renounceOwnership", target)
 12565  }
 12566  
 12567  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
 12568  //
 12569  // Solidity: function renounceOwnership(address target) returns()
 12570  func (_SeigToken *SeigTokenSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
 12571  	return _SeigToken.Contract.RenounceOwnership(&_SeigToken.TransactOpts, target)
 12572  }
 12573  
 12574  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
 12575  //
 12576  // Solidity: function renounceOwnership(address target) returns()
 12577  func (_SeigToken *SeigTokenTransactorSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
 12578  	return _SeigToken.Contract.RenounceOwnership(&_SeigToken.TransactOpts, target)
 12579  }
 12580  
 12581  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
 12582  //
 12583  // Solidity: function renounceOwnership() returns()
 12584  func (_SeigToken *SeigTokenTransactor) RenounceOwnership0(opts *bind.TransactOpts) (*types.Transaction, error) {
 12585  	return _SeigToken.contract.Transact(opts, "renounceOwnership0")
 12586  }
 12587  
 12588  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
 12589  //
 12590  // Solidity: function renounceOwnership() returns()
 12591  func (_SeigToken *SeigTokenSession) RenounceOwnership0() (*types.Transaction, error) {
 12592  	return _SeigToken.Contract.RenounceOwnership0(&_SeigToken.TransactOpts)
 12593  }
 12594  
 12595  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
 12596  //
 12597  // Solidity: function renounceOwnership() returns()
 12598  func (_SeigToken *SeigTokenTransactorSession) RenounceOwnership0() (*types.Transaction, error) {
 12599  	return _SeigToken.Contract.RenounceOwnership0(&_SeigToken.TransactOpts)
 12600  }
 12601  
 12602  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
 12603  //
 12604  // Solidity: function renouncePauser(address target) returns()
 12605  func (_SeigToken *SeigTokenTransactor) RenouncePauser(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
 12606  	return _SeigToken.contract.Transact(opts, "renouncePauser", target)
 12607  }
 12608  
 12609  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
 12610  //
 12611  // Solidity: function renouncePauser(address target) returns()
 12612  func (_SeigToken *SeigTokenSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
 12613  	return _SeigToken.Contract.RenouncePauser(&_SeigToken.TransactOpts, target)
 12614  }
 12615  
 12616  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
 12617  //
 12618  // Solidity: function renouncePauser(address target) returns()
 12619  func (_SeigToken *SeigTokenTransactorSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
 12620  	return _SeigToken.Contract.RenouncePauser(&_SeigToken.TransactOpts, target)
 12621  }
 12622  
 12623  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
 12624  //
 12625  // Solidity: function setSeigManager(address _seigManager) returns()
 12626  func (_SeigToken *SeigTokenTransactor) SetSeigManager(opts *bind.TransactOpts, _seigManager common.Address) (*types.Transaction, error) {
 12627  	return _SeigToken.contract.Transact(opts, "setSeigManager", _seigManager)
 12628  }
 12629  
 12630  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
 12631  //
 12632  // Solidity: function setSeigManager(address _seigManager) returns()
 12633  func (_SeigToken *SeigTokenSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) {
 12634  	return _SeigToken.Contract.SetSeigManager(&_SeigToken.TransactOpts, _seigManager)
 12635  }
 12636  
 12637  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
 12638  //
 12639  // Solidity: function setSeigManager(address _seigManager) returns()
 12640  func (_SeigToken *SeigTokenTransactorSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) {
 12641  	return _SeigToken.Contract.SetSeigManager(&_SeigToken.TransactOpts, _seigManager)
 12642  }
 12643  
 12644  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
 12645  //
 12646  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
 12647  func (_SeigToken *SeigTokenTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
 12648  	return _SeigToken.contract.Transact(opts, "transfer", recipient, amount)
 12649  }
 12650  
 12651  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
 12652  //
 12653  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
 12654  func (_SeigToken *SeigTokenSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
 12655  	return _SeigToken.Contract.Transfer(&_SeigToken.TransactOpts, recipient, amount)
 12656  }
 12657  
 12658  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
 12659  //
 12660  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
 12661  func (_SeigToken *SeigTokenTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
 12662  	return _SeigToken.Contract.Transfer(&_SeigToken.TransactOpts, recipient, amount)
 12663  }
 12664  
 12665  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
 12666  //
 12667  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
 12668  func (_SeigToken *SeigTokenTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
 12669  	return _SeigToken.contract.Transact(opts, "transferFrom", sender, recipient, amount)
 12670  }
 12671  
 12672  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
 12673  //
 12674  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
 12675  func (_SeigToken *SeigTokenSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
 12676  	return _SeigToken.Contract.TransferFrom(&_SeigToken.TransactOpts, sender, recipient, amount)
 12677  }
 12678  
 12679  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
 12680  //
 12681  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
 12682  func (_SeigToken *SeigTokenTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
 12683  	return _SeigToken.Contract.TransferFrom(&_SeigToken.TransactOpts, sender, recipient, amount)
 12684  }
 12685  
 12686  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
 12687  //
 12688  // Solidity: function transferOwnership(address target, address newOwner) returns()
 12689  func (_SeigToken *SeigTokenTransactor) TransferOwnership(opts *bind.TransactOpts, target common.Address, newOwner common.Address) (*types.Transaction, error) {
 12690  	return _SeigToken.contract.Transact(opts, "transferOwnership", target, newOwner)
 12691  }
 12692  
 12693  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
 12694  //
 12695  // Solidity: function transferOwnership(address target, address newOwner) returns()
 12696  func (_SeigToken *SeigTokenSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
 12697  	return _SeigToken.Contract.TransferOwnership(&_SeigToken.TransactOpts, target, newOwner)
 12698  }
 12699  
 12700  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
 12701  //
 12702  // Solidity: function transferOwnership(address target, address newOwner) returns()
 12703  func (_SeigToken *SeigTokenTransactorSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
 12704  	return _SeigToken.Contract.TransferOwnership(&_SeigToken.TransactOpts, target, newOwner)
 12705  }
 12706  
 12707  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
 12708  //
 12709  // Solidity: function transferOwnership(address newOwner) returns()
 12710  func (_SeigToken *SeigTokenTransactor) TransferOwnership0(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
 12711  	return _SeigToken.contract.Transact(opts, "transferOwnership0", newOwner)
 12712  }
 12713  
 12714  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
 12715  //
 12716  // Solidity: function transferOwnership(address newOwner) returns()
 12717  func (_SeigToken *SeigTokenSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
 12718  	return _SeigToken.Contract.TransferOwnership0(&_SeigToken.TransactOpts, newOwner)
 12719  }
 12720  
 12721  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
 12722  //
 12723  // Solidity: function transferOwnership(address newOwner) returns()
 12724  func (_SeigToken *SeigTokenTransactorSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
 12725  	return _SeigToken.Contract.TransferOwnership0(&_SeigToken.TransactOpts, newOwner)
 12726  }
 12727  
 12728  // 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.
 12729  type SeigTokenApprovalIterator struct {
 12730  	Event *SeigTokenApproval // Event containing the contract specifics and raw log
 12731  
 12732  	contract *bind.BoundContract // Generic contract to use for unpacking event data
 12733  	event    string              // Event name to use for unpacking event data
 12734  
 12735  	logs chan types.Log        // Log channel receiving the found contract events
 12736  	sub  ethereum.Subscription // Subscription for errors, completion and termination
 12737  	done bool                  // Whether the subscription completed delivering logs
 12738  	fail error                 // Occurred error to stop iteration
 12739  }
 12740  
 12741  // Next advances the iterator to the subsequent event, returning whether there
 12742  // are any more events found. In case of a retrieval or parsing error, false is
 12743  // returned and Error() can be queried for the exact failure.
 12744  func (it *SeigTokenApprovalIterator) Next() bool {
 12745  	// If the iterator failed, stop iterating
 12746  	if it.fail != nil {
 12747  		return false
 12748  	}
 12749  	// If the iterator completed, deliver directly whatever's available
 12750  	if it.done {
 12751  		select {
 12752  		case log := <-it.logs:
 12753  			it.Event = new(SeigTokenApproval)
 12754  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 12755  				it.fail = err
 12756  				return false
 12757  			}
 12758  			it.Event.Raw = log
 12759  			return true
 12760  
 12761  		default:
 12762  			return false
 12763  		}
 12764  	}
 12765  	// Iterator still in progress, wait for either a data or an error event
 12766  	select {
 12767  	case log := <-it.logs:
 12768  		it.Event = new(SeigTokenApproval)
 12769  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 12770  			it.fail = err
 12771  			return false
 12772  		}
 12773  		it.Event.Raw = log
 12774  		return true
 12775  
 12776  	case err := <-it.sub.Err():
 12777  		it.done = true
 12778  		it.fail = err
 12779  		return it.Next()
 12780  	}
 12781  }
 12782  
 12783  // Error returns any retrieval or parsing error occurred during filtering.
 12784  func (it *SeigTokenApprovalIterator) Error() error {
 12785  	return it.fail
 12786  }
 12787  
 12788  // Close terminates the iteration process, releasing any pending underlying
 12789  // resources.
 12790  func (it *SeigTokenApprovalIterator) Close() error {
 12791  	it.sub.Unsubscribe()
 12792  	return nil
 12793  }
 12794  
 12795  // SeigTokenApproval represents a Approval event raised by the SeigToken contract.
 12796  type SeigTokenApproval struct {
 12797  	Owner   common.Address
 12798  	Spender common.Address
 12799  	Value   *big.Int
 12800  	Raw     types.Log // Blockchain specific contextual infos
 12801  }
 12802  
 12803  // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
 12804  //
 12805  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
 12806  func (_SeigToken *SeigTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*SeigTokenApprovalIterator, error) {
 12807  
 12808  	var ownerRule []interface{}
 12809  	for _, ownerItem := range owner {
 12810  		ownerRule = append(ownerRule, ownerItem)
 12811  	}
 12812  	var spenderRule []interface{}
 12813  	for _, spenderItem := range spender {
 12814  		spenderRule = append(spenderRule, spenderItem)
 12815  	}
 12816  
 12817  	logs, sub, err := _SeigToken.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
 12818  	if err != nil {
 12819  		return nil, err
 12820  	}
 12821  	return &SeigTokenApprovalIterator{contract: _SeigToken.contract, event: "Approval", logs: logs, sub: sub}, nil
 12822  }
 12823  
 12824  // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
 12825  //
 12826  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
 12827  func (_SeigToken *SeigTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *SeigTokenApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
 12828  
 12829  	var ownerRule []interface{}
 12830  	for _, ownerItem := range owner {
 12831  		ownerRule = append(ownerRule, ownerItem)
 12832  	}
 12833  	var spenderRule []interface{}
 12834  	for _, spenderItem := range spender {
 12835  		spenderRule = append(spenderRule, spenderItem)
 12836  	}
 12837  
 12838  	logs, sub, err := _SeigToken.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
 12839  	if err != nil {
 12840  		return nil, err
 12841  	}
 12842  	return event.NewSubscription(func(quit <-chan struct{}) error {
 12843  		defer sub.Unsubscribe()
 12844  		for {
 12845  			select {
 12846  			case log := <-logs:
 12847  				// New log arrived, parse the event and forward to the user
 12848  				event := new(SeigTokenApproval)
 12849  				if err := _SeigToken.contract.UnpackLog(event, "Approval", log); err != nil {
 12850  					return err
 12851  				}
 12852  				event.Raw = log
 12853  
 12854  				select {
 12855  				case sink <- event:
 12856  				case err := <-sub.Err():
 12857  					return err
 12858  				case <-quit:
 12859  					return nil
 12860  				}
 12861  			case err := <-sub.Err():
 12862  				return err
 12863  			case <-quit:
 12864  				return nil
 12865  			}
 12866  		}
 12867  	}), nil
 12868  }
 12869  
 12870  // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
 12871  //
 12872  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
 12873  func (_SeigToken *SeigTokenFilterer) ParseApproval(log types.Log) (*SeigTokenApproval, error) {
 12874  	event := new(SeigTokenApproval)
 12875  	if err := _SeigToken.contract.UnpackLog(event, "Approval", log); err != nil {
 12876  		return nil, err
 12877  	}
 12878  	return event, nil
 12879  }
 12880  
 12881  // 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.
 12882  type SeigTokenOwnershipTransferredIterator struct {
 12883  	Event *SeigTokenOwnershipTransferred // Event containing the contract specifics and raw log
 12884  
 12885  	contract *bind.BoundContract // Generic contract to use for unpacking event data
 12886  	event    string              // Event name to use for unpacking event data
 12887  
 12888  	logs chan types.Log        // Log channel receiving the found contract events
 12889  	sub  ethereum.Subscription // Subscription for errors, completion and termination
 12890  	done bool                  // Whether the subscription completed delivering logs
 12891  	fail error                 // Occurred error to stop iteration
 12892  }
 12893  
 12894  // Next advances the iterator to the subsequent event, returning whether there
 12895  // are any more events found. In case of a retrieval or parsing error, false is
 12896  // returned and Error() can be queried for the exact failure.
 12897  func (it *SeigTokenOwnershipTransferredIterator) Next() bool {
 12898  	// If the iterator failed, stop iterating
 12899  	if it.fail != nil {
 12900  		return false
 12901  	}
 12902  	// If the iterator completed, deliver directly whatever's available
 12903  	if it.done {
 12904  		select {
 12905  		case log := <-it.logs:
 12906  			it.Event = new(SeigTokenOwnershipTransferred)
 12907  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 12908  				it.fail = err
 12909  				return false
 12910  			}
 12911  			it.Event.Raw = log
 12912  			return true
 12913  
 12914  		default:
 12915  			return false
 12916  		}
 12917  	}
 12918  	// Iterator still in progress, wait for either a data or an error event
 12919  	select {
 12920  	case log := <-it.logs:
 12921  		it.Event = new(SeigTokenOwnershipTransferred)
 12922  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 12923  			it.fail = err
 12924  			return false
 12925  		}
 12926  		it.Event.Raw = log
 12927  		return true
 12928  
 12929  	case err := <-it.sub.Err():
 12930  		it.done = true
 12931  		it.fail = err
 12932  		return it.Next()
 12933  	}
 12934  }
 12935  
 12936  // Error returns any retrieval or parsing error occurred during filtering.
 12937  func (it *SeigTokenOwnershipTransferredIterator) Error() error {
 12938  	return it.fail
 12939  }
 12940  
 12941  // Close terminates the iteration process, releasing any pending underlying
 12942  // resources.
 12943  func (it *SeigTokenOwnershipTransferredIterator) Close() error {
 12944  	it.sub.Unsubscribe()
 12945  	return nil
 12946  }
 12947  
 12948  // SeigTokenOwnershipTransferred represents a OwnershipTransferred event raised by the SeigToken contract.
 12949  type SeigTokenOwnershipTransferred struct {
 12950  	PreviousOwner common.Address
 12951  	NewOwner      common.Address
 12952  	Raw           types.Log // Blockchain specific contextual infos
 12953  }
 12954  
 12955  // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
 12956  //
 12957  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
 12958  func (_SeigToken *SeigTokenFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*SeigTokenOwnershipTransferredIterator, error) {
 12959  
 12960  	var previousOwnerRule []interface{}
 12961  	for _, previousOwnerItem := range previousOwner {
 12962  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
 12963  	}
 12964  	var newOwnerRule []interface{}
 12965  	for _, newOwnerItem := range newOwner {
 12966  		newOwnerRule = append(newOwnerRule, newOwnerItem)
 12967  	}
 12968  
 12969  	logs, sub, err := _SeigToken.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
 12970  	if err != nil {
 12971  		return nil, err
 12972  	}
 12973  	return &SeigTokenOwnershipTransferredIterator{contract: _SeigToken.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
 12974  }
 12975  
 12976  // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
 12977  //
 12978  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
 12979  func (_SeigToken *SeigTokenFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *SeigTokenOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {
 12980  
 12981  	var previousOwnerRule []interface{}
 12982  	for _, previousOwnerItem := range previousOwner {
 12983  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
 12984  	}
 12985  	var newOwnerRule []interface{}
 12986  	for _, newOwnerItem := range newOwner {
 12987  		newOwnerRule = append(newOwnerRule, newOwnerItem)
 12988  	}
 12989  
 12990  	logs, sub, err := _SeigToken.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
 12991  	if err != nil {
 12992  		return nil, err
 12993  	}
 12994  	return event.NewSubscription(func(quit <-chan struct{}) error {
 12995  		defer sub.Unsubscribe()
 12996  		for {
 12997  			select {
 12998  			case log := <-logs:
 12999  				// New log arrived, parse the event and forward to the user
 13000  				event := new(SeigTokenOwnershipTransferred)
 13001  				if err := _SeigToken.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
 13002  					return err
 13003  				}
 13004  				event.Raw = log
 13005  
 13006  				select {
 13007  				case sink <- event:
 13008  				case err := <-sub.Err():
 13009  					return err
 13010  				case <-quit:
 13011  					return nil
 13012  				}
 13013  			case err := <-sub.Err():
 13014  				return err
 13015  			case <-quit:
 13016  				return nil
 13017  			}
 13018  		}
 13019  	}), nil
 13020  }
 13021  
 13022  // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
 13023  //
 13024  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
 13025  func (_SeigToken *SeigTokenFilterer) ParseOwnershipTransferred(log types.Log) (*SeigTokenOwnershipTransferred, error) {
 13026  	event := new(SeigTokenOwnershipTransferred)
 13027  	if err := _SeigToken.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
 13028  		return nil, err
 13029  	}
 13030  	return event, nil
 13031  }
 13032  
 13033  // 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.
 13034  type SeigTokenTransferIterator struct {
 13035  	Event *SeigTokenTransfer // Event containing the contract specifics and raw log
 13036  
 13037  	contract *bind.BoundContract // Generic contract to use for unpacking event data
 13038  	event    string              // Event name to use for unpacking event data
 13039  
 13040  	logs chan types.Log        // Log channel receiving the found contract events
 13041  	sub  ethereum.Subscription // Subscription for errors, completion and termination
 13042  	done bool                  // Whether the subscription completed delivering logs
 13043  	fail error                 // Occurred error to stop iteration
 13044  }
 13045  
 13046  // Next advances the iterator to the subsequent event, returning whether there
 13047  // are any more events found. In case of a retrieval or parsing error, false is
 13048  // returned and Error() can be queried for the exact failure.
 13049  func (it *SeigTokenTransferIterator) Next() bool {
 13050  	// If the iterator failed, stop iterating
 13051  	if it.fail != nil {
 13052  		return false
 13053  	}
 13054  	// If the iterator completed, deliver directly whatever's available
 13055  	if it.done {
 13056  		select {
 13057  		case log := <-it.logs:
 13058  			it.Event = new(SeigTokenTransfer)
 13059  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 13060  				it.fail = err
 13061  				return false
 13062  			}
 13063  			it.Event.Raw = log
 13064  			return true
 13065  
 13066  		default:
 13067  			return false
 13068  		}
 13069  	}
 13070  	// Iterator still in progress, wait for either a data or an error event
 13071  	select {
 13072  	case log := <-it.logs:
 13073  		it.Event = new(SeigTokenTransfer)
 13074  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 13075  			it.fail = err
 13076  			return false
 13077  		}
 13078  		it.Event.Raw = log
 13079  		return true
 13080  
 13081  	case err := <-it.sub.Err():
 13082  		it.done = true
 13083  		it.fail = err
 13084  		return it.Next()
 13085  	}
 13086  }
 13087  
 13088  // Error returns any retrieval or parsing error occurred during filtering.
 13089  func (it *SeigTokenTransferIterator) Error() error {
 13090  	return it.fail
 13091  }
 13092  
 13093  // Close terminates the iteration process, releasing any pending underlying
 13094  // resources.
 13095  func (it *SeigTokenTransferIterator) Close() error {
 13096  	it.sub.Unsubscribe()
 13097  	return nil
 13098  }
 13099  
 13100  // SeigTokenTransfer represents a Transfer event raised by the SeigToken contract.
 13101  type SeigTokenTransfer struct {
 13102  	From  common.Address
 13103  	To    common.Address
 13104  	Value *big.Int
 13105  	Raw   types.Log // Blockchain specific contextual infos
 13106  }
 13107  
 13108  // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
 13109  //
 13110  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
 13111  func (_SeigToken *SeigTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*SeigTokenTransferIterator, error) {
 13112  
 13113  	var fromRule []interface{}
 13114  	for _, fromItem := range from {
 13115  		fromRule = append(fromRule, fromItem)
 13116  	}
 13117  	var toRule []interface{}
 13118  	for _, toItem := range to {
 13119  		toRule = append(toRule, toItem)
 13120  	}
 13121  
 13122  	logs, sub, err := _SeigToken.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
 13123  	if err != nil {
 13124  		return nil, err
 13125  	}
 13126  	return &SeigTokenTransferIterator{contract: _SeigToken.contract, event: "Transfer", logs: logs, sub: sub}, nil
 13127  }
 13128  
 13129  // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
 13130  //
 13131  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
 13132  func (_SeigToken *SeigTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *SeigTokenTransfer, from []common.Address, to []common.Address) (event.Subscription, error) {
 13133  
 13134  	var fromRule []interface{}
 13135  	for _, fromItem := range from {
 13136  		fromRule = append(fromRule, fromItem)
 13137  	}
 13138  	var toRule []interface{}
 13139  	for _, toItem := range to {
 13140  		toRule = append(toRule, toItem)
 13141  	}
 13142  
 13143  	logs, sub, err := _SeigToken.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
 13144  	if err != nil {
 13145  		return nil, err
 13146  	}
 13147  	return event.NewSubscription(func(quit <-chan struct{}) error {
 13148  		defer sub.Unsubscribe()
 13149  		for {
 13150  			select {
 13151  			case log := <-logs:
 13152  				// New log arrived, parse the event and forward to the user
 13153  				event := new(SeigTokenTransfer)
 13154  				if err := _SeigToken.contract.UnpackLog(event, "Transfer", log); err != nil {
 13155  					return err
 13156  				}
 13157  				event.Raw = log
 13158  
 13159  				select {
 13160  				case sink <- event:
 13161  				case err := <-sub.Err():
 13162  					return err
 13163  				case <-quit:
 13164  					return nil
 13165  				}
 13166  			case err := <-sub.Err():
 13167  				return err
 13168  			case <-quit:
 13169  				return nil
 13170  			}
 13171  		}
 13172  	}), nil
 13173  }
 13174  
 13175  // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
 13176  //
 13177  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
 13178  func (_SeigToken *SeigTokenFilterer) ParseTransfer(log types.Log) (*SeigTokenTransfer, error) {
 13179  	event := new(SeigTokenTransfer)
 13180  	if err := _SeigToken.contract.UnpackLog(event, "Transfer", log); err != nil {
 13181  		return nil, err
 13182  	}
 13183  	return event, nil
 13184  }
 13185  
 13186  // WTONABI is the input ABI used to generate the binding from.
 13187  const WTONABI = "[{\"inputs\":[{\"internalType\":\"contractERC20Mintable\",\"name\":\"_ton\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":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\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burnFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"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\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tonAmount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onApprove\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"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\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tonAmount\",\"type\":\"uint256\"}],\"name\":\"swapFromTON\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tonAmount\",\"type\":\"uint256\"}],\"name\":\"swapFromTONAndTransfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"name\":\"swapToTON\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"name\":\"swapToTONAndTransfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"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\":\"ton\",\"outputs\":[{\"internalType\":\"contractERC20Mintable\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"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\"}]"
 13188  
 13189  // WTONFuncSigs maps the 4-byte function signature to its string representation.
 13190  var WTONFuncSigs = map[string]string{
 13191  	"6cd28f9a": "INTERFACE_ID_ON_APPROVE()",
 13192  	"983b2d56": "addMinter(address)",
 13193  	"dd62ed3e": "allowance(address,address)",
 13194  	"095ea7b3": "approve(address,uint256)",
 13195  	"cae9ca51": "approveAndCall(address,uint256,bytes)",
 13196  	"70a08231": "balanceOf(address)",
 13197  	"42966c68": "burn(uint256)",
 13198  	"79cc6790": "burnFrom(address,uint256)",
 13199  	"313ce567": "decimals()",
 13200  	"a457c2d7": "decreaseAllowance(address,uint256)",
 13201  	"39509351": "increaseAllowance(address,uint256)",
 13202  	"aa271e1a": "isMinter(address)",
 13203  	"8f32d59b": "isOwner()",
 13204  	"40c10f19": "mint(address,uint256)",
 13205  	"06fdde03": "name()",
 13206  	"4273ca16": "onApprove(address,address,uint256,bytes)",
 13207  	"8da5cb5b": "owner()",
 13208  	"98650275": "renounceMinter()",
 13209  	"5f112c68": "renounceMinter(address)",
 13210  	"715018a6": "renounceOwnership()",
 13211  	"38bf3cfa": "renounceOwnership(address)",
 13212  	"41eb24bb": "renouncePauser(address)",
 13213  	"6fb7f558": "seigManager()",
 13214  	"7657f20a": "setSeigManager(address)",
 13215  	"01ffc9a7": "supportsInterface(bytes4)",
 13216  	"e34869d7": "swapFromTON(uint256)",
 13217  	"588420b7": "swapFromTONAndTransfer(address,uint256)",
 13218  	"f53fe70f": "swapToTON(uint256)",
 13219  	"e3b99e85": "swapToTONAndTransfer(address,uint256)",
 13220  	"95d89b41": "symbol()",
 13221  	"cc48b947": "ton()",
 13222  	"18160ddd": "totalSupply()",
 13223  	"a9059cbb": "transfer(address,uint256)",
 13224  	"23b872dd": "transferFrom(address,address,uint256)",
 13225  	"f2fde38b": "transferOwnership(address)",
 13226  	"6d435421": "transferOwnership(address,address)",
 13227  }
 13228  
 13229  // WTONBin is the compiled bytecode used for deploying new contracts.
 13230  var WTONBin = "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"
 13231  
 13232  // DeployWTON deploys a new Ethereum contract, binding an instance of WTON to it.
 13233  func DeployWTON(auth *bind.TransactOpts, backend bind.ContractBackend, _ton common.Address) (common.Address, *types.Transaction, *WTON, error) {
 13234  	parsed, err := abi.JSON(strings.NewReader(WTONABI))
 13235  	if err != nil {
 13236  		return common.Address{}, nil, nil, err
 13237  	}
 13238  
 13239  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(WTONBin), backend, _ton)
 13240  	if err != nil {
 13241  		return common.Address{}, nil, nil, err
 13242  	}
 13243  	return address, tx, &WTON{WTONCaller: WTONCaller{contract: contract}, WTONTransactor: WTONTransactor{contract: contract}, WTONFilterer: WTONFilterer{contract: contract}}, nil
 13244  }
 13245  
 13246  // WTON is an auto generated Go binding around an Ethereum contract.
 13247  type WTON struct {
 13248  	WTONCaller     // Read-only binding to the contract
 13249  	WTONTransactor // Write-only binding to the contract
 13250  	WTONFilterer   // Log filterer for contract events
 13251  }
 13252  
 13253  // WTONCaller is an auto generated read-only Go binding around an Ethereum contract.
 13254  type WTONCaller struct {
 13255  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 13256  }
 13257  
 13258  // WTONTransactor is an auto generated write-only Go binding around an Ethereum contract.
 13259  type WTONTransactor struct {
 13260  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 13261  }
 13262  
 13263  // WTONFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
 13264  type WTONFilterer struct {
 13265  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
 13266  }
 13267  
 13268  // WTONSession is an auto generated Go binding around an Ethereum contract,
 13269  // with pre-set call and transact options.
 13270  type WTONSession struct {
 13271  	Contract     *WTON             // Generic contract binding to set the session for
 13272  	CallOpts     bind.CallOpts     // Call options to use throughout this session
 13273  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
 13274  }
 13275  
 13276  // WTONCallerSession is an auto generated read-only Go binding around an Ethereum contract,
 13277  // with pre-set call options.
 13278  type WTONCallerSession struct {
 13279  	Contract *WTONCaller   // Generic contract caller binding to set the session for
 13280  	CallOpts bind.CallOpts // Call options to use throughout this session
 13281  }
 13282  
 13283  // WTONTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
 13284  // with pre-set transact options.
 13285  type WTONTransactorSession struct {
 13286  	Contract     *WTONTransactor   // Generic contract transactor binding to set the session for
 13287  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
 13288  }
 13289  
 13290  // WTONRaw is an auto generated low-level Go binding around an Ethereum contract.
 13291  type WTONRaw struct {
 13292  	Contract *WTON // Generic contract binding to access the raw methods on
 13293  }
 13294  
 13295  // WTONCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
 13296  type WTONCallerRaw struct {
 13297  	Contract *WTONCaller // Generic read-only contract binding to access the raw methods on
 13298  }
 13299  
 13300  // WTONTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
 13301  type WTONTransactorRaw struct {
 13302  	Contract *WTONTransactor // Generic write-only contract binding to access the raw methods on
 13303  }
 13304  
 13305  // NewWTON creates a new instance of WTON, bound to a specific deployed contract.
 13306  func NewWTON(address common.Address, backend bind.ContractBackend) (*WTON, error) {
 13307  	contract, err := bindWTON(address, backend, backend, backend)
 13308  	if err != nil {
 13309  		return nil, err
 13310  	}
 13311  	return &WTON{WTONCaller: WTONCaller{contract: contract}, WTONTransactor: WTONTransactor{contract: contract}, WTONFilterer: WTONFilterer{contract: contract}}, nil
 13312  }
 13313  
 13314  // NewWTONCaller creates a new read-only instance of WTON, bound to a specific deployed contract.
 13315  func NewWTONCaller(address common.Address, caller bind.ContractCaller) (*WTONCaller, error) {
 13316  	contract, err := bindWTON(address, caller, nil, nil)
 13317  	if err != nil {
 13318  		return nil, err
 13319  	}
 13320  	return &WTONCaller{contract: contract}, nil
 13321  }
 13322  
 13323  // NewWTONTransactor creates a new write-only instance of WTON, bound to a specific deployed contract.
 13324  func NewWTONTransactor(address common.Address, transactor bind.ContractTransactor) (*WTONTransactor, error) {
 13325  	contract, err := bindWTON(address, nil, transactor, nil)
 13326  	if err != nil {
 13327  		return nil, err
 13328  	}
 13329  	return &WTONTransactor{contract: contract}, nil
 13330  }
 13331  
 13332  // NewWTONFilterer creates a new log filterer instance of WTON, bound to a specific deployed contract.
 13333  func NewWTONFilterer(address common.Address, filterer bind.ContractFilterer) (*WTONFilterer, error) {
 13334  	contract, err := bindWTON(address, nil, nil, filterer)
 13335  	if err != nil {
 13336  		return nil, err
 13337  	}
 13338  	return &WTONFilterer{contract: contract}, nil
 13339  }
 13340  
 13341  // bindWTON binds a generic wrapper to an already deployed contract.
 13342  func bindWTON(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
 13343  	parsed, err := abi.JSON(strings.NewReader(WTONABI))
 13344  	if err != nil {
 13345  		return nil, err
 13346  	}
 13347  	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
 13348  }
 13349  
 13350  // Call invokes the (constant) contract method with params as input values and
 13351  // sets the output to result. The result type might be a single field for simple
 13352  // returns, a slice of interfaces for anonymous returns and a struct for named
 13353  // returns.
 13354  func (_WTON *WTONRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 13355  	return _WTON.Contract.WTONCaller.contract.Call(opts, result, method, params...)
 13356  }
 13357  
 13358  // Transfer initiates a plain transaction to move funds to the contract, calling
 13359  // its default method if one is available.
 13360  func (_WTON *WTONRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 13361  	return _WTON.Contract.WTONTransactor.contract.Transfer(opts)
 13362  }
 13363  
 13364  // Transact invokes the (paid) contract method with params as input values.
 13365  func (_WTON *WTONRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 13366  	return _WTON.Contract.WTONTransactor.contract.Transact(opts, method, params...)
 13367  }
 13368  
 13369  // Call invokes the (constant) contract method with params as input values and
 13370  // sets the output to result. The result type might be a single field for simple
 13371  // returns, a slice of interfaces for anonymous returns and a struct for named
 13372  // returns.
 13373  func (_WTON *WTONCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
 13374  	return _WTON.Contract.contract.Call(opts, result, method, params...)
 13375  }
 13376  
 13377  // Transfer initiates a plain transaction to move funds to the contract, calling
 13378  // its default method if one is available.
 13379  func (_WTON *WTONTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
 13380  	return _WTON.Contract.contract.Transfer(opts)
 13381  }
 13382  
 13383  // Transact invokes the (paid) contract method with params as input values.
 13384  func (_WTON *WTONTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
 13385  	return _WTON.Contract.contract.Transact(opts, method, params...)
 13386  }
 13387  
 13388  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
 13389  //
 13390  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
 13391  func (_WTON *WTONCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) {
 13392  	var (
 13393  		ret0 = new([4]byte)
 13394  	)
 13395  	out := ret0
 13396  	err := _WTON.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE")
 13397  	return *ret0, err
 13398  }
 13399  
 13400  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
 13401  //
 13402  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
 13403  func (_WTON *WTONSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
 13404  	return _WTON.Contract.INTERFACEIDONAPPROVE(&_WTON.CallOpts)
 13405  }
 13406  
 13407  // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a.
 13408  //
 13409  // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4)
 13410  func (_WTON *WTONCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) {
 13411  	return _WTON.Contract.INTERFACEIDONAPPROVE(&_WTON.CallOpts)
 13412  }
 13413  
 13414  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
 13415  //
 13416  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
 13417  func (_WTON *WTONCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) {
 13418  	var (
 13419  		ret0 = new(*big.Int)
 13420  	)
 13421  	out := ret0
 13422  	err := _WTON.contract.Call(opts, out, "allowance", owner, spender)
 13423  	return *ret0, err
 13424  }
 13425  
 13426  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
 13427  //
 13428  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
 13429  func (_WTON *WTONSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
 13430  	return _WTON.Contract.Allowance(&_WTON.CallOpts, owner, spender)
 13431  }
 13432  
 13433  // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e.
 13434  //
 13435  // Solidity: function allowance(address owner, address spender) constant returns(uint256)
 13436  func (_WTON *WTONCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) {
 13437  	return _WTON.Contract.Allowance(&_WTON.CallOpts, owner, spender)
 13438  }
 13439  
 13440  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
 13441  //
 13442  // Solidity: function balanceOf(address account) constant returns(uint256)
 13443  func (_WTON *WTONCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
 13444  	var (
 13445  		ret0 = new(*big.Int)
 13446  	)
 13447  	out := ret0
 13448  	err := _WTON.contract.Call(opts, out, "balanceOf", account)
 13449  	return *ret0, err
 13450  }
 13451  
 13452  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
 13453  //
 13454  // Solidity: function balanceOf(address account) constant returns(uint256)
 13455  func (_WTON *WTONSession) BalanceOf(account common.Address) (*big.Int, error) {
 13456  	return _WTON.Contract.BalanceOf(&_WTON.CallOpts, account)
 13457  }
 13458  
 13459  // BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
 13460  //
 13461  // Solidity: function balanceOf(address account) constant returns(uint256)
 13462  func (_WTON *WTONCallerSession) BalanceOf(account common.Address) (*big.Int, error) {
 13463  	return _WTON.Contract.BalanceOf(&_WTON.CallOpts, account)
 13464  }
 13465  
 13466  // Decimals is a free data retrieval call binding the contract method 0x313ce567.
 13467  //
 13468  // Solidity: function decimals() constant returns(uint8)
 13469  func (_WTON *WTONCaller) Decimals(opts *bind.CallOpts) (uint8, error) {
 13470  	var (
 13471  		ret0 = new(uint8)
 13472  	)
 13473  	out := ret0
 13474  	err := _WTON.contract.Call(opts, out, "decimals")
 13475  	return *ret0, err
 13476  }
 13477  
 13478  // Decimals is a free data retrieval call binding the contract method 0x313ce567.
 13479  //
 13480  // Solidity: function decimals() constant returns(uint8)
 13481  func (_WTON *WTONSession) Decimals() (uint8, error) {
 13482  	return _WTON.Contract.Decimals(&_WTON.CallOpts)
 13483  }
 13484  
 13485  // Decimals is a free data retrieval call binding the contract method 0x313ce567.
 13486  //
 13487  // Solidity: function decimals() constant returns(uint8)
 13488  func (_WTON *WTONCallerSession) Decimals() (uint8, error) {
 13489  	return _WTON.Contract.Decimals(&_WTON.CallOpts)
 13490  }
 13491  
 13492  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
 13493  //
 13494  // Solidity: function isMinter(address account) constant returns(bool)
 13495  func (_WTON *WTONCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) {
 13496  	var (
 13497  		ret0 = new(bool)
 13498  	)
 13499  	out := ret0
 13500  	err := _WTON.contract.Call(opts, out, "isMinter", account)
 13501  	return *ret0, err
 13502  }
 13503  
 13504  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
 13505  //
 13506  // Solidity: function isMinter(address account) constant returns(bool)
 13507  func (_WTON *WTONSession) IsMinter(account common.Address) (bool, error) {
 13508  	return _WTON.Contract.IsMinter(&_WTON.CallOpts, account)
 13509  }
 13510  
 13511  // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a.
 13512  //
 13513  // Solidity: function isMinter(address account) constant returns(bool)
 13514  func (_WTON *WTONCallerSession) IsMinter(account common.Address) (bool, error) {
 13515  	return _WTON.Contract.IsMinter(&_WTON.CallOpts, account)
 13516  }
 13517  
 13518  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
 13519  //
 13520  // Solidity: function isOwner() constant returns(bool)
 13521  func (_WTON *WTONCaller) IsOwner(opts *bind.CallOpts) (bool, error) {
 13522  	var (
 13523  		ret0 = new(bool)
 13524  	)
 13525  	out := ret0
 13526  	err := _WTON.contract.Call(opts, out, "isOwner")
 13527  	return *ret0, err
 13528  }
 13529  
 13530  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
 13531  //
 13532  // Solidity: function isOwner() constant returns(bool)
 13533  func (_WTON *WTONSession) IsOwner() (bool, error) {
 13534  	return _WTON.Contract.IsOwner(&_WTON.CallOpts)
 13535  }
 13536  
 13537  // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b.
 13538  //
 13539  // Solidity: function isOwner() constant returns(bool)
 13540  func (_WTON *WTONCallerSession) IsOwner() (bool, error) {
 13541  	return _WTON.Contract.IsOwner(&_WTON.CallOpts)
 13542  }
 13543  
 13544  // Name is a free data retrieval call binding the contract method 0x06fdde03.
 13545  //
 13546  // Solidity: function name() constant returns(string)
 13547  func (_WTON *WTONCaller) Name(opts *bind.CallOpts) (string, error) {
 13548  	var (
 13549  		ret0 = new(string)
 13550  	)
 13551  	out := ret0
 13552  	err := _WTON.contract.Call(opts, out, "name")
 13553  	return *ret0, err
 13554  }
 13555  
 13556  // Name is a free data retrieval call binding the contract method 0x06fdde03.
 13557  //
 13558  // Solidity: function name() constant returns(string)
 13559  func (_WTON *WTONSession) Name() (string, error) {
 13560  	return _WTON.Contract.Name(&_WTON.CallOpts)
 13561  }
 13562  
 13563  // Name is a free data retrieval call binding the contract method 0x06fdde03.
 13564  //
 13565  // Solidity: function name() constant returns(string)
 13566  func (_WTON *WTONCallerSession) Name() (string, error) {
 13567  	return _WTON.Contract.Name(&_WTON.CallOpts)
 13568  }
 13569  
 13570  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
 13571  //
 13572  // Solidity: function owner() constant returns(address)
 13573  func (_WTON *WTONCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
 13574  	var (
 13575  		ret0 = new(common.Address)
 13576  	)
 13577  	out := ret0
 13578  	err := _WTON.contract.Call(opts, out, "owner")
 13579  	return *ret0, err
 13580  }
 13581  
 13582  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
 13583  //
 13584  // Solidity: function owner() constant returns(address)
 13585  func (_WTON *WTONSession) Owner() (common.Address, error) {
 13586  	return _WTON.Contract.Owner(&_WTON.CallOpts)
 13587  }
 13588  
 13589  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
 13590  //
 13591  // Solidity: function owner() constant returns(address)
 13592  func (_WTON *WTONCallerSession) Owner() (common.Address, error) {
 13593  	return _WTON.Contract.Owner(&_WTON.CallOpts)
 13594  }
 13595  
 13596  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
 13597  //
 13598  // Solidity: function seigManager() constant returns(address)
 13599  func (_WTON *WTONCaller) SeigManager(opts *bind.CallOpts) (common.Address, error) {
 13600  	var (
 13601  		ret0 = new(common.Address)
 13602  	)
 13603  	out := ret0
 13604  	err := _WTON.contract.Call(opts, out, "seigManager")
 13605  	return *ret0, err
 13606  }
 13607  
 13608  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
 13609  //
 13610  // Solidity: function seigManager() constant returns(address)
 13611  func (_WTON *WTONSession) SeigManager() (common.Address, error) {
 13612  	return _WTON.Contract.SeigManager(&_WTON.CallOpts)
 13613  }
 13614  
 13615  // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558.
 13616  //
 13617  // Solidity: function seigManager() constant returns(address)
 13618  func (_WTON *WTONCallerSession) SeigManager() (common.Address, error) {
 13619  	return _WTON.Contract.SeigManager(&_WTON.CallOpts)
 13620  }
 13621  
 13622  // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
 13623  //
 13624  // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool)
 13625  func (_WTON *WTONCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
 13626  	var (
 13627  		ret0 = new(bool)
 13628  	)
 13629  	out := ret0
 13630  	err := _WTON.contract.Call(opts, out, "supportsInterface", interfaceId)
 13631  	return *ret0, err
 13632  }
 13633  
 13634  // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
 13635  //
 13636  // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool)
 13637  func (_WTON *WTONSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
 13638  	return _WTON.Contract.SupportsInterface(&_WTON.CallOpts, interfaceId)
 13639  }
 13640  
 13641  // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
 13642  //
 13643  // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool)
 13644  func (_WTON *WTONCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
 13645  	return _WTON.Contract.SupportsInterface(&_WTON.CallOpts, interfaceId)
 13646  }
 13647  
 13648  // Symbol is a free data retrieval call binding the contract method 0x95d89b41.
 13649  //
 13650  // Solidity: function symbol() constant returns(string)
 13651  func (_WTON *WTONCaller) Symbol(opts *bind.CallOpts) (string, error) {
 13652  	var (
 13653  		ret0 = new(string)
 13654  	)
 13655  	out := ret0
 13656  	err := _WTON.contract.Call(opts, out, "symbol")
 13657  	return *ret0, err
 13658  }
 13659  
 13660  // Symbol is a free data retrieval call binding the contract method 0x95d89b41.
 13661  //
 13662  // Solidity: function symbol() constant returns(string)
 13663  func (_WTON *WTONSession) Symbol() (string, error) {
 13664  	return _WTON.Contract.Symbol(&_WTON.CallOpts)
 13665  }
 13666  
 13667  // Symbol is a free data retrieval call binding the contract method 0x95d89b41.
 13668  //
 13669  // Solidity: function symbol() constant returns(string)
 13670  func (_WTON *WTONCallerSession) Symbol() (string, error) {
 13671  	return _WTON.Contract.Symbol(&_WTON.CallOpts)
 13672  }
 13673  
 13674  // Ton is a free data retrieval call binding the contract method 0xcc48b947.
 13675  //
 13676  // Solidity: function ton() constant returns(address)
 13677  func (_WTON *WTONCaller) Ton(opts *bind.CallOpts) (common.Address, error) {
 13678  	var (
 13679  		ret0 = new(common.Address)
 13680  	)
 13681  	out := ret0
 13682  	err := _WTON.contract.Call(opts, out, "ton")
 13683  	return *ret0, err
 13684  }
 13685  
 13686  // Ton is a free data retrieval call binding the contract method 0xcc48b947.
 13687  //
 13688  // Solidity: function ton() constant returns(address)
 13689  func (_WTON *WTONSession) Ton() (common.Address, error) {
 13690  	return _WTON.Contract.Ton(&_WTON.CallOpts)
 13691  }
 13692  
 13693  // Ton is a free data retrieval call binding the contract method 0xcc48b947.
 13694  //
 13695  // Solidity: function ton() constant returns(address)
 13696  func (_WTON *WTONCallerSession) Ton() (common.Address, error) {
 13697  	return _WTON.Contract.Ton(&_WTON.CallOpts)
 13698  }
 13699  
 13700  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
 13701  //
 13702  // Solidity: function totalSupply() constant returns(uint256)
 13703  func (_WTON *WTONCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
 13704  	var (
 13705  		ret0 = new(*big.Int)
 13706  	)
 13707  	out := ret0
 13708  	err := _WTON.contract.Call(opts, out, "totalSupply")
 13709  	return *ret0, err
 13710  }
 13711  
 13712  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
 13713  //
 13714  // Solidity: function totalSupply() constant returns(uint256)
 13715  func (_WTON *WTONSession) TotalSupply() (*big.Int, error) {
 13716  	return _WTON.Contract.TotalSupply(&_WTON.CallOpts)
 13717  }
 13718  
 13719  // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
 13720  //
 13721  // Solidity: function totalSupply() constant returns(uint256)
 13722  func (_WTON *WTONCallerSession) TotalSupply() (*big.Int, error) {
 13723  	return _WTON.Contract.TotalSupply(&_WTON.CallOpts)
 13724  }
 13725  
 13726  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
 13727  //
 13728  // Solidity: function addMinter(address account) returns()
 13729  func (_WTON *WTONTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) {
 13730  	return _WTON.contract.Transact(opts, "addMinter", account)
 13731  }
 13732  
 13733  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
 13734  //
 13735  // Solidity: function addMinter(address account) returns()
 13736  func (_WTON *WTONSession) AddMinter(account common.Address) (*types.Transaction, error) {
 13737  	return _WTON.Contract.AddMinter(&_WTON.TransactOpts, account)
 13738  }
 13739  
 13740  // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56.
 13741  //
 13742  // Solidity: function addMinter(address account) returns()
 13743  func (_WTON *WTONTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) {
 13744  	return _WTON.Contract.AddMinter(&_WTON.TransactOpts, account)
 13745  }
 13746  
 13747  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
 13748  //
 13749  // Solidity: function approve(address spender, uint256 amount) returns(bool)
 13750  func (_WTON *WTONTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) {
 13751  	return _WTON.contract.Transact(opts, "approve", spender, amount)
 13752  }
 13753  
 13754  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
 13755  //
 13756  // Solidity: function approve(address spender, uint256 amount) returns(bool)
 13757  func (_WTON *WTONSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
 13758  	return _WTON.Contract.Approve(&_WTON.TransactOpts, spender, amount)
 13759  }
 13760  
 13761  // Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
 13762  //
 13763  // Solidity: function approve(address spender, uint256 amount) returns(bool)
 13764  func (_WTON *WTONTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) {
 13765  	return _WTON.Contract.Approve(&_WTON.TransactOpts, spender, amount)
 13766  }
 13767  
 13768  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
 13769  //
 13770  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
 13771  func (_WTON *WTONTransactor) ApproveAndCall(opts *bind.TransactOpts, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
 13772  	return _WTON.contract.Transact(opts, "approveAndCall", spender, amount, data)
 13773  }
 13774  
 13775  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
 13776  //
 13777  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
 13778  func (_WTON *WTONSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
 13779  	return _WTON.Contract.ApproveAndCall(&_WTON.TransactOpts, spender, amount, data)
 13780  }
 13781  
 13782  // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51.
 13783  //
 13784  // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool)
 13785  func (_WTON *WTONTransactorSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) {
 13786  	return _WTON.Contract.ApproveAndCall(&_WTON.TransactOpts, spender, amount, data)
 13787  }
 13788  
 13789  // Burn is a paid mutator transaction binding the contract method 0x42966c68.
 13790  //
 13791  // Solidity: function burn(uint256 amount) returns()
 13792  func (_WTON *WTONTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) {
 13793  	return _WTON.contract.Transact(opts, "burn", amount)
 13794  }
 13795  
 13796  // Burn is a paid mutator transaction binding the contract method 0x42966c68.
 13797  //
 13798  // Solidity: function burn(uint256 amount) returns()
 13799  func (_WTON *WTONSession) Burn(amount *big.Int) (*types.Transaction, error) {
 13800  	return _WTON.Contract.Burn(&_WTON.TransactOpts, amount)
 13801  }
 13802  
 13803  // Burn is a paid mutator transaction binding the contract method 0x42966c68.
 13804  //
 13805  // Solidity: function burn(uint256 amount) returns()
 13806  func (_WTON *WTONTransactorSession) Burn(amount *big.Int) (*types.Transaction, error) {
 13807  	return _WTON.Contract.Burn(&_WTON.TransactOpts, amount)
 13808  }
 13809  
 13810  // BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
 13811  //
 13812  // Solidity: function burnFrom(address account, uint256 amount) returns()
 13813  func (_WTON *WTONTransactor) BurnFrom(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) {
 13814  	return _WTON.contract.Transact(opts, "burnFrom", account, amount)
 13815  }
 13816  
 13817  // BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
 13818  //
 13819  // Solidity: function burnFrom(address account, uint256 amount) returns()
 13820  func (_WTON *WTONSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) {
 13821  	return _WTON.Contract.BurnFrom(&_WTON.TransactOpts, account, amount)
 13822  }
 13823  
 13824  // BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790.
 13825  //
 13826  // Solidity: function burnFrom(address account, uint256 amount) returns()
 13827  func (_WTON *WTONTransactorSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) {
 13828  	return _WTON.Contract.BurnFrom(&_WTON.TransactOpts, account, amount)
 13829  }
 13830  
 13831  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
 13832  //
 13833  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
 13834  func (_WTON *WTONTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
 13835  	return _WTON.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue)
 13836  }
 13837  
 13838  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
 13839  //
 13840  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
 13841  func (_WTON *WTONSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
 13842  	return _WTON.Contract.DecreaseAllowance(&_WTON.TransactOpts, spender, subtractedValue)
 13843  }
 13844  
 13845  // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7.
 13846  //
 13847  // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool)
 13848  func (_WTON *WTONTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) {
 13849  	return _WTON.Contract.DecreaseAllowance(&_WTON.TransactOpts, spender, subtractedValue)
 13850  }
 13851  
 13852  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
 13853  //
 13854  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
 13855  func (_WTON *WTONTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
 13856  	return _WTON.contract.Transact(opts, "increaseAllowance", spender, addedValue)
 13857  }
 13858  
 13859  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
 13860  //
 13861  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
 13862  func (_WTON *WTONSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
 13863  	return _WTON.Contract.IncreaseAllowance(&_WTON.TransactOpts, spender, addedValue)
 13864  }
 13865  
 13866  // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351.
 13867  //
 13868  // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool)
 13869  func (_WTON *WTONTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) {
 13870  	return _WTON.Contract.IncreaseAllowance(&_WTON.TransactOpts, spender, addedValue)
 13871  }
 13872  
 13873  // Mint is a paid mutator transaction binding the contract method 0x40c10f19.
 13874  //
 13875  // Solidity: function mint(address account, uint256 amount) returns(bool)
 13876  func (_WTON *WTONTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) {
 13877  	return _WTON.contract.Transact(opts, "mint", account, amount)
 13878  }
 13879  
 13880  // Mint is a paid mutator transaction binding the contract method 0x40c10f19.
 13881  //
 13882  // Solidity: function mint(address account, uint256 amount) returns(bool)
 13883  func (_WTON *WTONSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
 13884  	return _WTON.Contract.Mint(&_WTON.TransactOpts, account, amount)
 13885  }
 13886  
 13887  // Mint is a paid mutator transaction binding the contract method 0x40c10f19.
 13888  //
 13889  // Solidity: function mint(address account, uint256 amount) returns(bool)
 13890  func (_WTON *WTONTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) {
 13891  	return _WTON.Contract.Mint(&_WTON.TransactOpts, account, amount)
 13892  }
 13893  
 13894  // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16.
 13895  //
 13896  // Solidity: function onApprove(address owner, address spender, uint256 tonAmount, bytes data) returns(bool)
 13897  func (_WTON *WTONTransactor) OnApprove(opts *bind.TransactOpts, owner common.Address, spender common.Address, tonAmount *big.Int, data []byte) (*types.Transaction, error) {
 13898  	return _WTON.contract.Transact(opts, "onApprove", owner, spender, tonAmount, data)
 13899  }
 13900  
 13901  // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16.
 13902  //
 13903  // Solidity: function onApprove(address owner, address spender, uint256 tonAmount, bytes data) returns(bool)
 13904  func (_WTON *WTONSession) OnApprove(owner common.Address, spender common.Address, tonAmount *big.Int, data []byte) (*types.Transaction, error) {
 13905  	return _WTON.Contract.OnApprove(&_WTON.TransactOpts, owner, spender, tonAmount, data)
 13906  }
 13907  
 13908  // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16.
 13909  //
 13910  // Solidity: function onApprove(address owner, address spender, uint256 tonAmount, bytes data) returns(bool)
 13911  func (_WTON *WTONTransactorSession) OnApprove(owner common.Address, spender common.Address, tonAmount *big.Int, data []byte) (*types.Transaction, error) {
 13912  	return _WTON.Contract.OnApprove(&_WTON.TransactOpts, owner, spender, tonAmount, data)
 13913  }
 13914  
 13915  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
 13916  //
 13917  // Solidity: function renounceMinter(address target) returns()
 13918  func (_WTON *WTONTransactor) RenounceMinter(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
 13919  	return _WTON.contract.Transact(opts, "renounceMinter", target)
 13920  }
 13921  
 13922  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
 13923  //
 13924  // Solidity: function renounceMinter(address target) returns()
 13925  func (_WTON *WTONSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
 13926  	return _WTON.Contract.RenounceMinter(&_WTON.TransactOpts, target)
 13927  }
 13928  
 13929  // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68.
 13930  //
 13931  // Solidity: function renounceMinter(address target) returns()
 13932  func (_WTON *WTONTransactorSession) RenounceMinter(target common.Address) (*types.Transaction, error) {
 13933  	return _WTON.Contract.RenounceMinter(&_WTON.TransactOpts, target)
 13934  }
 13935  
 13936  // RenounceMinter0 is a paid mutator transaction binding the contract method 0x98650275.
 13937  //
 13938  // Solidity: function renounceMinter() returns()
 13939  func (_WTON *WTONTransactor) RenounceMinter0(opts *bind.TransactOpts) (*types.Transaction, error) {
 13940  	return _WTON.contract.Transact(opts, "renounceMinter0")
 13941  }
 13942  
 13943  // RenounceMinter0 is a paid mutator transaction binding the contract method 0x98650275.
 13944  //
 13945  // Solidity: function renounceMinter() returns()
 13946  func (_WTON *WTONSession) RenounceMinter0() (*types.Transaction, error) {
 13947  	return _WTON.Contract.RenounceMinter0(&_WTON.TransactOpts)
 13948  }
 13949  
 13950  // RenounceMinter0 is a paid mutator transaction binding the contract method 0x98650275.
 13951  //
 13952  // Solidity: function renounceMinter() returns()
 13953  func (_WTON *WTONTransactorSession) RenounceMinter0() (*types.Transaction, error) {
 13954  	return _WTON.Contract.RenounceMinter0(&_WTON.TransactOpts)
 13955  }
 13956  
 13957  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
 13958  //
 13959  // Solidity: function renounceOwnership(address target) returns()
 13960  func (_WTON *WTONTransactor) RenounceOwnership(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
 13961  	return _WTON.contract.Transact(opts, "renounceOwnership", target)
 13962  }
 13963  
 13964  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
 13965  //
 13966  // Solidity: function renounceOwnership(address target) returns()
 13967  func (_WTON *WTONSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
 13968  	return _WTON.Contract.RenounceOwnership(&_WTON.TransactOpts, target)
 13969  }
 13970  
 13971  // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa.
 13972  //
 13973  // Solidity: function renounceOwnership(address target) returns()
 13974  func (_WTON *WTONTransactorSession) RenounceOwnership(target common.Address) (*types.Transaction, error) {
 13975  	return _WTON.Contract.RenounceOwnership(&_WTON.TransactOpts, target)
 13976  }
 13977  
 13978  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
 13979  //
 13980  // Solidity: function renounceOwnership() returns()
 13981  func (_WTON *WTONTransactor) RenounceOwnership0(opts *bind.TransactOpts) (*types.Transaction, error) {
 13982  	return _WTON.contract.Transact(opts, "renounceOwnership0")
 13983  }
 13984  
 13985  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
 13986  //
 13987  // Solidity: function renounceOwnership() returns()
 13988  func (_WTON *WTONSession) RenounceOwnership0() (*types.Transaction, error) {
 13989  	return _WTON.Contract.RenounceOwnership0(&_WTON.TransactOpts)
 13990  }
 13991  
 13992  // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6.
 13993  //
 13994  // Solidity: function renounceOwnership() returns()
 13995  func (_WTON *WTONTransactorSession) RenounceOwnership0() (*types.Transaction, error) {
 13996  	return _WTON.Contract.RenounceOwnership0(&_WTON.TransactOpts)
 13997  }
 13998  
 13999  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
 14000  //
 14001  // Solidity: function renouncePauser(address target) returns()
 14002  func (_WTON *WTONTransactor) RenouncePauser(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) {
 14003  	return _WTON.contract.Transact(opts, "renouncePauser", target)
 14004  }
 14005  
 14006  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
 14007  //
 14008  // Solidity: function renouncePauser(address target) returns()
 14009  func (_WTON *WTONSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
 14010  	return _WTON.Contract.RenouncePauser(&_WTON.TransactOpts, target)
 14011  }
 14012  
 14013  // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb.
 14014  //
 14015  // Solidity: function renouncePauser(address target) returns()
 14016  func (_WTON *WTONTransactorSession) RenouncePauser(target common.Address) (*types.Transaction, error) {
 14017  	return _WTON.Contract.RenouncePauser(&_WTON.TransactOpts, target)
 14018  }
 14019  
 14020  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
 14021  //
 14022  // Solidity: function setSeigManager(address _seigManager) returns()
 14023  func (_WTON *WTONTransactor) SetSeigManager(opts *bind.TransactOpts, _seigManager common.Address) (*types.Transaction, error) {
 14024  	return _WTON.contract.Transact(opts, "setSeigManager", _seigManager)
 14025  }
 14026  
 14027  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
 14028  //
 14029  // Solidity: function setSeigManager(address _seigManager) returns()
 14030  func (_WTON *WTONSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) {
 14031  	return _WTON.Contract.SetSeigManager(&_WTON.TransactOpts, _seigManager)
 14032  }
 14033  
 14034  // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a.
 14035  //
 14036  // Solidity: function setSeigManager(address _seigManager) returns()
 14037  func (_WTON *WTONTransactorSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) {
 14038  	return _WTON.Contract.SetSeigManager(&_WTON.TransactOpts, _seigManager)
 14039  }
 14040  
 14041  // SwapFromTON is a paid mutator transaction binding the contract method 0xe34869d7.
 14042  //
 14043  // Solidity: function swapFromTON(uint256 tonAmount) returns(bool)
 14044  func (_WTON *WTONTransactor) SwapFromTON(opts *bind.TransactOpts, tonAmount *big.Int) (*types.Transaction, error) {
 14045  	return _WTON.contract.Transact(opts, "swapFromTON", tonAmount)
 14046  }
 14047  
 14048  // SwapFromTON is a paid mutator transaction binding the contract method 0xe34869d7.
 14049  //
 14050  // Solidity: function swapFromTON(uint256 tonAmount) returns(bool)
 14051  func (_WTON *WTONSession) SwapFromTON(tonAmount *big.Int) (*types.Transaction, error) {
 14052  	return _WTON.Contract.SwapFromTON(&_WTON.TransactOpts, tonAmount)
 14053  }
 14054  
 14055  // SwapFromTON is a paid mutator transaction binding the contract method 0xe34869d7.
 14056  //
 14057  // Solidity: function swapFromTON(uint256 tonAmount) returns(bool)
 14058  func (_WTON *WTONTransactorSession) SwapFromTON(tonAmount *big.Int) (*types.Transaction, error) {
 14059  	return _WTON.Contract.SwapFromTON(&_WTON.TransactOpts, tonAmount)
 14060  }
 14061  
 14062  // SwapFromTONAndTransfer is a paid mutator transaction binding the contract method 0x588420b7.
 14063  //
 14064  // Solidity: function swapFromTONAndTransfer(address to, uint256 tonAmount) returns(bool)
 14065  func (_WTON *WTONTransactor) SwapFromTONAndTransfer(opts *bind.TransactOpts, to common.Address, tonAmount *big.Int) (*types.Transaction, error) {
 14066  	return _WTON.contract.Transact(opts, "swapFromTONAndTransfer", to, tonAmount)
 14067  }
 14068  
 14069  // SwapFromTONAndTransfer is a paid mutator transaction binding the contract method 0x588420b7.
 14070  //
 14071  // Solidity: function swapFromTONAndTransfer(address to, uint256 tonAmount) returns(bool)
 14072  func (_WTON *WTONSession) SwapFromTONAndTransfer(to common.Address, tonAmount *big.Int) (*types.Transaction, error) {
 14073  	return _WTON.Contract.SwapFromTONAndTransfer(&_WTON.TransactOpts, to, tonAmount)
 14074  }
 14075  
 14076  // SwapFromTONAndTransfer is a paid mutator transaction binding the contract method 0x588420b7.
 14077  //
 14078  // Solidity: function swapFromTONAndTransfer(address to, uint256 tonAmount) returns(bool)
 14079  func (_WTON *WTONTransactorSession) SwapFromTONAndTransfer(to common.Address, tonAmount *big.Int) (*types.Transaction, error) {
 14080  	return _WTON.Contract.SwapFromTONAndTransfer(&_WTON.TransactOpts, to, tonAmount)
 14081  }
 14082  
 14083  // SwapToTON is a paid mutator transaction binding the contract method 0xf53fe70f.
 14084  //
 14085  // Solidity: function swapToTON(uint256 wtonAmount) returns(bool)
 14086  func (_WTON *WTONTransactor) SwapToTON(opts *bind.TransactOpts, wtonAmount *big.Int) (*types.Transaction, error) {
 14087  	return _WTON.contract.Transact(opts, "swapToTON", wtonAmount)
 14088  }
 14089  
 14090  // SwapToTON is a paid mutator transaction binding the contract method 0xf53fe70f.
 14091  //
 14092  // Solidity: function swapToTON(uint256 wtonAmount) returns(bool)
 14093  func (_WTON *WTONSession) SwapToTON(wtonAmount *big.Int) (*types.Transaction, error) {
 14094  	return _WTON.Contract.SwapToTON(&_WTON.TransactOpts, wtonAmount)
 14095  }
 14096  
 14097  // SwapToTON is a paid mutator transaction binding the contract method 0xf53fe70f.
 14098  //
 14099  // Solidity: function swapToTON(uint256 wtonAmount) returns(bool)
 14100  func (_WTON *WTONTransactorSession) SwapToTON(wtonAmount *big.Int) (*types.Transaction, error) {
 14101  	return _WTON.Contract.SwapToTON(&_WTON.TransactOpts, wtonAmount)
 14102  }
 14103  
 14104  // SwapToTONAndTransfer is a paid mutator transaction binding the contract method 0xe3b99e85.
 14105  //
 14106  // Solidity: function swapToTONAndTransfer(address to, uint256 wtonAmount) returns(bool)
 14107  func (_WTON *WTONTransactor) SwapToTONAndTransfer(opts *bind.TransactOpts, to common.Address, wtonAmount *big.Int) (*types.Transaction, error) {
 14108  	return _WTON.contract.Transact(opts, "swapToTONAndTransfer", to, wtonAmount)
 14109  }
 14110  
 14111  // SwapToTONAndTransfer is a paid mutator transaction binding the contract method 0xe3b99e85.
 14112  //
 14113  // Solidity: function swapToTONAndTransfer(address to, uint256 wtonAmount) returns(bool)
 14114  func (_WTON *WTONSession) SwapToTONAndTransfer(to common.Address, wtonAmount *big.Int) (*types.Transaction, error) {
 14115  	return _WTON.Contract.SwapToTONAndTransfer(&_WTON.TransactOpts, to, wtonAmount)
 14116  }
 14117  
 14118  // SwapToTONAndTransfer is a paid mutator transaction binding the contract method 0xe3b99e85.
 14119  //
 14120  // Solidity: function swapToTONAndTransfer(address to, uint256 wtonAmount) returns(bool)
 14121  func (_WTON *WTONTransactorSession) SwapToTONAndTransfer(to common.Address, wtonAmount *big.Int) (*types.Transaction, error) {
 14122  	return _WTON.Contract.SwapToTONAndTransfer(&_WTON.TransactOpts, to, wtonAmount)
 14123  }
 14124  
 14125  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
 14126  //
 14127  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
 14128  func (_WTON *WTONTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
 14129  	return _WTON.contract.Transact(opts, "transfer", recipient, amount)
 14130  }
 14131  
 14132  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
 14133  //
 14134  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
 14135  func (_WTON *WTONSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
 14136  	return _WTON.Contract.Transfer(&_WTON.TransactOpts, recipient, amount)
 14137  }
 14138  
 14139  // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
 14140  //
 14141  // Solidity: function transfer(address recipient, uint256 amount) returns(bool)
 14142  func (_WTON *WTONTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) {
 14143  	return _WTON.Contract.Transfer(&_WTON.TransactOpts, recipient, amount)
 14144  }
 14145  
 14146  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
 14147  //
 14148  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
 14149  func (_WTON *WTONTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
 14150  	return _WTON.contract.Transact(opts, "transferFrom", sender, recipient, amount)
 14151  }
 14152  
 14153  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
 14154  //
 14155  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
 14156  func (_WTON *WTONSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
 14157  	return _WTON.Contract.TransferFrom(&_WTON.TransactOpts, sender, recipient, amount)
 14158  }
 14159  
 14160  // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd.
 14161  //
 14162  // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool)
 14163  func (_WTON *WTONTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) {
 14164  	return _WTON.Contract.TransferFrom(&_WTON.TransactOpts, sender, recipient, amount)
 14165  }
 14166  
 14167  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
 14168  //
 14169  // Solidity: function transferOwnership(address target, address newOwner) returns()
 14170  func (_WTON *WTONTransactor) TransferOwnership(opts *bind.TransactOpts, target common.Address, newOwner common.Address) (*types.Transaction, error) {
 14171  	return _WTON.contract.Transact(opts, "transferOwnership", target, newOwner)
 14172  }
 14173  
 14174  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
 14175  //
 14176  // Solidity: function transferOwnership(address target, address newOwner) returns()
 14177  func (_WTON *WTONSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
 14178  	return _WTON.Contract.TransferOwnership(&_WTON.TransactOpts, target, newOwner)
 14179  }
 14180  
 14181  // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421.
 14182  //
 14183  // Solidity: function transferOwnership(address target, address newOwner) returns()
 14184  func (_WTON *WTONTransactorSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) {
 14185  	return _WTON.Contract.TransferOwnership(&_WTON.TransactOpts, target, newOwner)
 14186  }
 14187  
 14188  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
 14189  //
 14190  // Solidity: function transferOwnership(address newOwner) returns()
 14191  func (_WTON *WTONTransactor) TransferOwnership0(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
 14192  	return _WTON.contract.Transact(opts, "transferOwnership0", newOwner)
 14193  }
 14194  
 14195  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
 14196  //
 14197  // Solidity: function transferOwnership(address newOwner) returns()
 14198  func (_WTON *WTONSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
 14199  	return _WTON.Contract.TransferOwnership0(&_WTON.TransactOpts, newOwner)
 14200  }
 14201  
 14202  // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b.
 14203  //
 14204  // Solidity: function transferOwnership(address newOwner) returns()
 14205  func (_WTON *WTONTransactorSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) {
 14206  	return _WTON.Contract.TransferOwnership0(&_WTON.TransactOpts, newOwner)
 14207  }
 14208  
 14209  // WTONApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the WTON contract.
 14210  type WTONApprovalIterator struct {
 14211  	Event *WTONApproval // Event containing the contract specifics and raw log
 14212  
 14213  	contract *bind.BoundContract // Generic contract to use for unpacking event data
 14214  	event    string              // Event name to use for unpacking event data
 14215  
 14216  	logs chan types.Log        // Log channel receiving the found contract events
 14217  	sub  ethereum.Subscription // Subscription for errors, completion and termination
 14218  	done bool                  // Whether the subscription completed delivering logs
 14219  	fail error                 // Occurred error to stop iteration
 14220  }
 14221  
 14222  // Next advances the iterator to the subsequent event, returning whether there
 14223  // are any more events found. In case of a retrieval or parsing error, false is
 14224  // returned and Error() can be queried for the exact failure.
 14225  func (it *WTONApprovalIterator) Next() bool {
 14226  	// If the iterator failed, stop iterating
 14227  	if it.fail != nil {
 14228  		return false
 14229  	}
 14230  	// If the iterator completed, deliver directly whatever's available
 14231  	if it.done {
 14232  		select {
 14233  		case log := <-it.logs:
 14234  			it.Event = new(WTONApproval)
 14235  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 14236  				it.fail = err
 14237  				return false
 14238  			}
 14239  			it.Event.Raw = log
 14240  			return true
 14241  
 14242  		default:
 14243  			return false
 14244  		}
 14245  	}
 14246  	// Iterator still in progress, wait for either a data or an error event
 14247  	select {
 14248  	case log := <-it.logs:
 14249  		it.Event = new(WTONApproval)
 14250  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 14251  			it.fail = err
 14252  			return false
 14253  		}
 14254  		it.Event.Raw = log
 14255  		return true
 14256  
 14257  	case err := <-it.sub.Err():
 14258  		it.done = true
 14259  		it.fail = err
 14260  		return it.Next()
 14261  	}
 14262  }
 14263  
 14264  // Error returns any retrieval or parsing error occurred during filtering.
 14265  func (it *WTONApprovalIterator) Error() error {
 14266  	return it.fail
 14267  }
 14268  
 14269  // Close terminates the iteration process, releasing any pending underlying
 14270  // resources.
 14271  func (it *WTONApprovalIterator) Close() error {
 14272  	it.sub.Unsubscribe()
 14273  	return nil
 14274  }
 14275  
 14276  // WTONApproval represents a Approval event raised by the WTON contract.
 14277  type WTONApproval struct {
 14278  	Owner   common.Address
 14279  	Spender common.Address
 14280  	Value   *big.Int
 14281  	Raw     types.Log // Blockchain specific contextual infos
 14282  }
 14283  
 14284  // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
 14285  //
 14286  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
 14287  func (_WTON *WTONFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*WTONApprovalIterator, error) {
 14288  
 14289  	var ownerRule []interface{}
 14290  	for _, ownerItem := range owner {
 14291  		ownerRule = append(ownerRule, ownerItem)
 14292  	}
 14293  	var spenderRule []interface{}
 14294  	for _, spenderItem := range spender {
 14295  		spenderRule = append(spenderRule, spenderItem)
 14296  	}
 14297  
 14298  	logs, sub, err := _WTON.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
 14299  	if err != nil {
 14300  		return nil, err
 14301  	}
 14302  	return &WTONApprovalIterator{contract: _WTON.contract, event: "Approval", logs: logs, sub: sub}, nil
 14303  }
 14304  
 14305  // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
 14306  //
 14307  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
 14308  func (_WTON *WTONFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *WTONApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) {
 14309  
 14310  	var ownerRule []interface{}
 14311  	for _, ownerItem := range owner {
 14312  		ownerRule = append(ownerRule, ownerItem)
 14313  	}
 14314  	var spenderRule []interface{}
 14315  	for _, spenderItem := range spender {
 14316  		spenderRule = append(spenderRule, spenderItem)
 14317  	}
 14318  
 14319  	logs, sub, err := _WTON.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule)
 14320  	if err != nil {
 14321  		return nil, err
 14322  	}
 14323  	return event.NewSubscription(func(quit <-chan struct{}) error {
 14324  		defer sub.Unsubscribe()
 14325  		for {
 14326  			select {
 14327  			case log := <-logs:
 14328  				// New log arrived, parse the event and forward to the user
 14329  				event := new(WTONApproval)
 14330  				if err := _WTON.contract.UnpackLog(event, "Approval", log); err != nil {
 14331  					return err
 14332  				}
 14333  				event.Raw = log
 14334  
 14335  				select {
 14336  				case sink <- event:
 14337  				case err := <-sub.Err():
 14338  					return err
 14339  				case <-quit:
 14340  					return nil
 14341  				}
 14342  			case err := <-sub.Err():
 14343  				return err
 14344  			case <-quit:
 14345  				return nil
 14346  			}
 14347  		}
 14348  	}), nil
 14349  }
 14350  
 14351  // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925.
 14352  //
 14353  // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value)
 14354  func (_WTON *WTONFilterer) ParseApproval(log types.Log) (*WTONApproval, error) {
 14355  	event := new(WTONApproval)
 14356  	if err := _WTON.contract.UnpackLog(event, "Approval", log); err != nil {
 14357  		return nil, err
 14358  	}
 14359  	return event, nil
 14360  }
 14361  
 14362  // WTONMinterAddedIterator is returned from FilterMinterAdded and is used to iterate over the raw logs and unpacked data for MinterAdded events raised by the WTON contract.
 14363  type WTONMinterAddedIterator struct {
 14364  	Event *WTONMinterAdded // Event containing the contract specifics and raw log
 14365  
 14366  	contract *bind.BoundContract // Generic contract to use for unpacking event data
 14367  	event    string              // Event name to use for unpacking event data
 14368  
 14369  	logs chan types.Log        // Log channel receiving the found contract events
 14370  	sub  ethereum.Subscription // Subscription for errors, completion and termination
 14371  	done bool                  // Whether the subscription completed delivering logs
 14372  	fail error                 // Occurred error to stop iteration
 14373  }
 14374  
 14375  // Next advances the iterator to the subsequent event, returning whether there
 14376  // are any more events found. In case of a retrieval or parsing error, false is
 14377  // returned and Error() can be queried for the exact failure.
 14378  func (it *WTONMinterAddedIterator) Next() bool {
 14379  	// If the iterator failed, stop iterating
 14380  	if it.fail != nil {
 14381  		return false
 14382  	}
 14383  	// If the iterator completed, deliver directly whatever's available
 14384  	if it.done {
 14385  		select {
 14386  		case log := <-it.logs:
 14387  			it.Event = new(WTONMinterAdded)
 14388  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 14389  				it.fail = err
 14390  				return false
 14391  			}
 14392  			it.Event.Raw = log
 14393  			return true
 14394  
 14395  		default:
 14396  			return false
 14397  		}
 14398  	}
 14399  	// Iterator still in progress, wait for either a data or an error event
 14400  	select {
 14401  	case log := <-it.logs:
 14402  		it.Event = new(WTONMinterAdded)
 14403  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 14404  			it.fail = err
 14405  			return false
 14406  		}
 14407  		it.Event.Raw = log
 14408  		return true
 14409  
 14410  	case err := <-it.sub.Err():
 14411  		it.done = true
 14412  		it.fail = err
 14413  		return it.Next()
 14414  	}
 14415  }
 14416  
 14417  // Error returns any retrieval or parsing error occurred during filtering.
 14418  func (it *WTONMinterAddedIterator) Error() error {
 14419  	return it.fail
 14420  }
 14421  
 14422  // Close terminates the iteration process, releasing any pending underlying
 14423  // resources.
 14424  func (it *WTONMinterAddedIterator) Close() error {
 14425  	it.sub.Unsubscribe()
 14426  	return nil
 14427  }
 14428  
 14429  // WTONMinterAdded represents a MinterAdded event raised by the WTON contract.
 14430  type WTONMinterAdded struct {
 14431  	Account common.Address
 14432  	Raw     types.Log // Blockchain specific contextual infos
 14433  }
 14434  
 14435  // FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
 14436  //
 14437  // Solidity: event MinterAdded(address indexed account)
 14438  func (_WTON *WTONFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*WTONMinterAddedIterator, error) {
 14439  
 14440  	var accountRule []interface{}
 14441  	for _, accountItem := range account {
 14442  		accountRule = append(accountRule, accountItem)
 14443  	}
 14444  
 14445  	logs, sub, err := _WTON.contract.FilterLogs(opts, "MinterAdded", accountRule)
 14446  	if err != nil {
 14447  		return nil, err
 14448  	}
 14449  	return &WTONMinterAddedIterator{contract: _WTON.contract, event: "MinterAdded", logs: logs, sub: sub}, nil
 14450  }
 14451  
 14452  // WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
 14453  //
 14454  // Solidity: event MinterAdded(address indexed account)
 14455  func (_WTON *WTONFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *WTONMinterAdded, account []common.Address) (event.Subscription, error) {
 14456  
 14457  	var accountRule []interface{}
 14458  	for _, accountItem := range account {
 14459  		accountRule = append(accountRule, accountItem)
 14460  	}
 14461  
 14462  	logs, sub, err := _WTON.contract.WatchLogs(opts, "MinterAdded", accountRule)
 14463  	if err != nil {
 14464  		return nil, err
 14465  	}
 14466  	return event.NewSubscription(func(quit <-chan struct{}) error {
 14467  		defer sub.Unsubscribe()
 14468  		for {
 14469  			select {
 14470  			case log := <-logs:
 14471  				// New log arrived, parse the event and forward to the user
 14472  				event := new(WTONMinterAdded)
 14473  				if err := _WTON.contract.UnpackLog(event, "MinterAdded", log); err != nil {
 14474  					return err
 14475  				}
 14476  				event.Raw = log
 14477  
 14478  				select {
 14479  				case sink <- event:
 14480  				case err := <-sub.Err():
 14481  					return err
 14482  				case <-quit:
 14483  					return nil
 14484  				}
 14485  			case err := <-sub.Err():
 14486  				return err
 14487  			case <-quit:
 14488  				return nil
 14489  			}
 14490  		}
 14491  	}), nil
 14492  }
 14493  
 14494  // ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6.
 14495  //
 14496  // Solidity: event MinterAdded(address indexed account)
 14497  func (_WTON *WTONFilterer) ParseMinterAdded(log types.Log) (*WTONMinterAdded, error) {
 14498  	event := new(WTONMinterAdded)
 14499  	if err := _WTON.contract.UnpackLog(event, "MinterAdded", log); err != nil {
 14500  		return nil, err
 14501  	}
 14502  	return event, nil
 14503  }
 14504  
 14505  // WTONMinterRemovedIterator is returned from FilterMinterRemoved and is used to iterate over the raw logs and unpacked data for MinterRemoved events raised by the WTON contract.
 14506  type WTONMinterRemovedIterator struct {
 14507  	Event *WTONMinterRemoved // Event containing the contract specifics and raw log
 14508  
 14509  	contract *bind.BoundContract // Generic contract to use for unpacking event data
 14510  	event    string              // Event name to use for unpacking event data
 14511  
 14512  	logs chan types.Log        // Log channel receiving the found contract events
 14513  	sub  ethereum.Subscription // Subscription for errors, completion and termination
 14514  	done bool                  // Whether the subscription completed delivering logs
 14515  	fail error                 // Occurred error to stop iteration
 14516  }
 14517  
 14518  // Next advances the iterator to the subsequent event, returning whether there
 14519  // are any more events found. In case of a retrieval or parsing error, false is
 14520  // returned and Error() can be queried for the exact failure.
 14521  func (it *WTONMinterRemovedIterator) Next() bool {
 14522  	// If the iterator failed, stop iterating
 14523  	if it.fail != nil {
 14524  		return false
 14525  	}
 14526  	// If the iterator completed, deliver directly whatever's available
 14527  	if it.done {
 14528  		select {
 14529  		case log := <-it.logs:
 14530  			it.Event = new(WTONMinterRemoved)
 14531  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 14532  				it.fail = err
 14533  				return false
 14534  			}
 14535  			it.Event.Raw = log
 14536  			return true
 14537  
 14538  		default:
 14539  			return false
 14540  		}
 14541  	}
 14542  	// Iterator still in progress, wait for either a data or an error event
 14543  	select {
 14544  	case log := <-it.logs:
 14545  		it.Event = new(WTONMinterRemoved)
 14546  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 14547  			it.fail = err
 14548  			return false
 14549  		}
 14550  		it.Event.Raw = log
 14551  		return true
 14552  
 14553  	case err := <-it.sub.Err():
 14554  		it.done = true
 14555  		it.fail = err
 14556  		return it.Next()
 14557  	}
 14558  }
 14559  
 14560  // Error returns any retrieval or parsing error occurred during filtering.
 14561  func (it *WTONMinterRemovedIterator) Error() error {
 14562  	return it.fail
 14563  }
 14564  
 14565  // Close terminates the iteration process, releasing any pending underlying
 14566  // resources.
 14567  func (it *WTONMinterRemovedIterator) Close() error {
 14568  	it.sub.Unsubscribe()
 14569  	return nil
 14570  }
 14571  
 14572  // WTONMinterRemoved represents a MinterRemoved event raised by the WTON contract.
 14573  type WTONMinterRemoved struct {
 14574  	Account common.Address
 14575  	Raw     types.Log // Blockchain specific contextual infos
 14576  }
 14577  
 14578  // FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
 14579  //
 14580  // Solidity: event MinterRemoved(address indexed account)
 14581  func (_WTON *WTONFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*WTONMinterRemovedIterator, error) {
 14582  
 14583  	var accountRule []interface{}
 14584  	for _, accountItem := range account {
 14585  		accountRule = append(accountRule, accountItem)
 14586  	}
 14587  
 14588  	logs, sub, err := _WTON.contract.FilterLogs(opts, "MinterRemoved", accountRule)
 14589  	if err != nil {
 14590  		return nil, err
 14591  	}
 14592  	return &WTONMinterRemovedIterator{contract: _WTON.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil
 14593  }
 14594  
 14595  // WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
 14596  //
 14597  // Solidity: event MinterRemoved(address indexed account)
 14598  func (_WTON *WTONFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *WTONMinterRemoved, account []common.Address) (event.Subscription, error) {
 14599  
 14600  	var accountRule []interface{}
 14601  	for _, accountItem := range account {
 14602  		accountRule = append(accountRule, accountItem)
 14603  	}
 14604  
 14605  	logs, sub, err := _WTON.contract.WatchLogs(opts, "MinterRemoved", accountRule)
 14606  	if err != nil {
 14607  		return nil, err
 14608  	}
 14609  	return event.NewSubscription(func(quit <-chan struct{}) error {
 14610  		defer sub.Unsubscribe()
 14611  		for {
 14612  			select {
 14613  			case log := <-logs:
 14614  				// New log arrived, parse the event and forward to the user
 14615  				event := new(WTONMinterRemoved)
 14616  				if err := _WTON.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
 14617  					return err
 14618  				}
 14619  				event.Raw = log
 14620  
 14621  				select {
 14622  				case sink <- event:
 14623  				case err := <-sub.Err():
 14624  					return err
 14625  				case <-quit:
 14626  					return nil
 14627  				}
 14628  			case err := <-sub.Err():
 14629  				return err
 14630  			case <-quit:
 14631  				return nil
 14632  			}
 14633  		}
 14634  	}), nil
 14635  }
 14636  
 14637  // ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692.
 14638  //
 14639  // Solidity: event MinterRemoved(address indexed account)
 14640  func (_WTON *WTONFilterer) ParseMinterRemoved(log types.Log) (*WTONMinterRemoved, error) {
 14641  	event := new(WTONMinterRemoved)
 14642  	if err := _WTON.contract.UnpackLog(event, "MinterRemoved", log); err != nil {
 14643  		return nil, err
 14644  	}
 14645  	return event, nil
 14646  }
 14647  
 14648  // WTONOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the WTON contract.
 14649  type WTONOwnershipTransferredIterator struct {
 14650  	Event *WTONOwnershipTransferred // Event containing the contract specifics and raw log
 14651  
 14652  	contract *bind.BoundContract // Generic contract to use for unpacking event data
 14653  	event    string              // Event name to use for unpacking event data
 14654  
 14655  	logs chan types.Log        // Log channel receiving the found contract events
 14656  	sub  ethereum.Subscription // Subscription for errors, completion and termination
 14657  	done bool                  // Whether the subscription completed delivering logs
 14658  	fail error                 // Occurred error to stop iteration
 14659  }
 14660  
 14661  // Next advances the iterator to the subsequent event, returning whether there
 14662  // are any more events found. In case of a retrieval or parsing error, false is
 14663  // returned and Error() can be queried for the exact failure.
 14664  func (it *WTONOwnershipTransferredIterator) Next() bool {
 14665  	// If the iterator failed, stop iterating
 14666  	if it.fail != nil {
 14667  		return false
 14668  	}
 14669  	// If the iterator completed, deliver directly whatever's available
 14670  	if it.done {
 14671  		select {
 14672  		case log := <-it.logs:
 14673  			it.Event = new(WTONOwnershipTransferred)
 14674  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 14675  				it.fail = err
 14676  				return false
 14677  			}
 14678  			it.Event.Raw = log
 14679  			return true
 14680  
 14681  		default:
 14682  			return false
 14683  		}
 14684  	}
 14685  	// Iterator still in progress, wait for either a data or an error event
 14686  	select {
 14687  	case log := <-it.logs:
 14688  		it.Event = new(WTONOwnershipTransferred)
 14689  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 14690  			it.fail = err
 14691  			return false
 14692  		}
 14693  		it.Event.Raw = log
 14694  		return true
 14695  
 14696  	case err := <-it.sub.Err():
 14697  		it.done = true
 14698  		it.fail = err
 14699  		return it.Next()
 14700  	}
 14701  }
 14702  
 14703  // Error returns any retrieval or parsing error occurred during filtering.
 14704  func (it *WTONOwnershipTransferredIterator) Error() error {
 14705  	return it.fail
 14706  }
 14707  
 14708  // Close terminates the iteration process, releasing any pending underlying
 14709  // resources.
 14710  func (it *WTONOwnershipTransferredIterator) Close() error {
 14711  	it.sub.Unsubscribe()
 14712  	return nil
 14713  }
 14714  
 14715  // WTONOwnershipTransferred represents a OwnershipTransferred event raised by the WTON contract.
 14716  type WTONOwnershipTransferred struct {
 14717  	PreviousOwner common.Address
 14718  	NewOwner      common.Address
 14719  	Raw           types.Log // Blockchain specific contextual infos
 14720  }
 14721  
 14722  // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
 14723  //
 14724  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
 14725  func (_WTON *WTONFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*WTONOwnershipTransferredIterator, error) {
 14726  
 14727  	var previousOwnerRule []interface{}
 14728  	for _, previousOwnerItem := range previousOwner {
 14729  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
 14730  	}
 14731  	var newOwnerRule []interface{}
 14732  	for _, newOwnerItem := range newOwner {
 14733  		newOwnerRule = append(newOwnerRule, newOwnerItem)
 14734  	}
 14735  
 14736  	logs, sub, err := _WTON.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
 14737  	if err != nil {
 14738  		return nil, err
 14739  	}
 14740  	return &WTONOwnershipTransferredIterator{contract: _WTON.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
 14741  }
 14742  
 14743  // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
 14744  //
 14745  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
 14746  func (_WTON *WTONFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *WTONOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {
 14747  
 14748  	var previousOwnerRule []interface{}
 14749  	for _, previousOwnerItem := range previousOwner {
 14750  		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
 14751  	}
 14752  	var newOwnerRule []interface{}
 14753  	for _, newOwnerItem := range newOwner {
 14754  		newOwnerRule = append(newOwnerRule, newOwnerItem)
 14755  	}
 14756  
 14757  	logs, sub, err := _WTON.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
 14758  	if err != nil {
 14759  		return nil, err
 14760  	}
 14761  	return event.NewSubscription(func(quit <-chan struct{}) error {
 14762  		defer sub.Unsubscribe()
 14763  		for {
 14764  			select {
 14765  			case log := <-logs:
 14766  				// New log arrived, parse the event and forward to the user
 14767  				event := new(WTONOwnershipTransferred)
 14768  				if err := _WTON.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
 14769  					return err
 14770  				}
 14771  				event.Raw = log
 14772  
 14773  				select {
 14774  				case sink <- event:
 14775  				case err := <-sub.Err():
 14776  					return err
 14777  				case <-quit:
 14778  					return nil
 14779  				}
 14780  			case err := <-sub.Err():
 14781  				return err
 14782  			case <-quit:
 14783  				return nil
 14784  			}
 14785  		}
 14786  	}), nil
 14787  }
 14788  
 14789  // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
 14790  //
 14791  // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
 14792  func (_WTON *WTONFilterer) ParseOwnershipTransferred(log types.Log) (*WTONOwnershipTransferred, error) {
 14793  	event := new(WTONOwnershipTransferred)
 14794  	if err := _WTON.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
 14795  		return nil, err
 14796  	}
 14797  	return event, nil
 14798  }
 14799  
 14800  // WTONTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the WTON contract.
 14801  type WTONTransferIterator struct {
 14802  	Event *WTONTransfer // Event containing the contract specifics and raw log
 14803  
 14804  	contract *bind.BoundContract // Generic contract to use for unpacking event data
 14805  	event    string              // Event name to use for unpacking event data
 14806  
 14807  	logs chan types.Log        // Log channel receiving the found contract events
 14808  	sub  ethereum.Subscription // Subscription for errors, completion and termination
 14809  	done bool                  // Whether the subscription completed delivering logs
 14810  	fail error                 // Occurred error to stop iteration
 14811  }
 14812  
 14813  // Next advances the iterator to the subsequent event, returning whether there
 14814  // are any more events found. In case of a retrieval or parsing error, false is
 14815  // returned and Error() can be queried for the exact failure.
 14816  func (it *WTONTransferIterator) Next() bool {
 14817  	// If the iterator failed, stop iterating
 14818  	if it.fail != nil {
 14819  		return false
 14820  	}
 14821  	// If the iterator completed, deliver directly whatever's available
 14822  	if it.done {
 14823  		select {
 14824  		case log := <-it.logs:
 14825  			it.Event = new(WTONTransfer)
 14826  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 14827  				it.fail = err
 14828  				return false
 14829  			}
 14830  			it.Event.Raw = log
 14831  			return true
 14832  
 14833  		default:
 14834  			return false
 14835  		}
 14836  	}
 14837  	// Iterator still in progress, wait for either a data or an error event
 14838  	select {
 14839  	case log := <-it.logs:
 14840  		it.Event = new(WTONTransfer)
 14841  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
 14842  			it.fail = err
 14843  			return false
 14844  		}
 14845  		it.Event.Raw = log
 14846  		return true
 14847  
 14848  	case err := <-it.sub.Err():
 14849  		it.done = true
 14850  		it.fail = err
 14851  		return it.Next()
 14852  	}
 14853  }
 14854  
 14855  // Error returns any retrieval or parsing error occurred during filtering.
 14856  func (it *WTONTransferIterator) Error() error {
 14857  	return it.fail
 14858  }
 14859  
 14860  // Close terminates the iteration process, releasing any pending underlying
 14861  // resources.
 14862  func (it *WTONTransferIterator) Close() error {
 14863  	it.sub.Unsubscribe()
 14864  	return nil
 14865  }
 14866  
 14867  // WTONTransfer represents a Transfer event raised by the WTON contract.
 14868  type WTONTransfer struct {
 14869  	From  common.Address
 14870  	To    common.Address
 14871  	Value *big.Int
 14872  	Raw   types.Log // Blockchain specific contextual infos
 14873  }
 14874  
 14875  // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
 14876  //
 14877  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
 14878  func (_WTON *WTONFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*WTONTransferIterator, error) {
 14879  
 14880  	var fromRule []interface{}
 14881  	for _, fromItem := range from {
 14882  		fromRule = append(fromRule, fromItem)
 14883  	}
 14884  	var toRule []interface{}
 14885  	for _, toItem := range to {
 14886  		toRule = append(toRule, toItem)
 14887  	}
 14888  
 14889  	logs, sub, err := _WTON.contract.FilterLogs(opts, "Transfer", fromRule, toRule)
 14890  	if err != nil {
 14891  		return nil, err
 14892  	}
 14893  	return &WTONTransferIterator{contract: _WTON.contract, event: "Transfer", logs: logs, sub: sub}, nil
 14894  }
 14895  
 14896  // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
 14897  //
 14898  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
 14899  func (_WTON *WTONFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *WTONTransfer, from []common.Address, to []common.Address) (event.Subscription, error) {
 14900  
 14901  	var fromRule []interface{}
 14902  	for _, fromItem := range from {
 14903  		fromRule = append(fromRule, fromItem)
 14904  	}
 14905  	var toRule []interface{}
 14906  	for _, toItem := range to {
 14907  		toRule = append(toRule, toItem)
 14908  	}
 14909  
 14910  	logs, sub, err := _WTON.contract.WatchLogs(opts, "Transfer", fromRule, toRule)
 14911  	if err != nil {
 14912  		return nil, err
 14913  	}
 14914  	return event.NewSubscription(func(quit <-chan struct{}) error {
 14915  		defer sub.Unsubscribe()
 14916  		for {
 14917  			select {
 14918  			case log := <-logs:
 14919  				// New log arrived, parse the event and forward to the user
 14920  				event := new(WTONTransfer)
 14921  				if err := _WTON.contract.UnpackLog(event, "Transfer", log); err != nil {
 14922  					return err
 14923  				}
 14924  				event.Raw = log
 14925  
 14926  				select {
 14927  				case sink <- event:
 14928  				case err := <-sub.Err():
 14929  					return err
 14930  				case <-quit:
 14931  					return nil
 14932  				}
 14933  			case err := <-sub.Err():
 14934  				return err
 14935  			case <-quit:
 14936  				return nil
 14937  			}
 14938  		}
 14939  	}), nil
 14940  }
 14941  
 14942  // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef.
 14943  //
 14944  // Solidity: event Transfer(address indexed from, address indexed to, uint256 value)
 14945  func (_WTON *WTONFilterer) ParseTransfer(log types.Log) (*WTONTransfer, error) {
 14946  	event := new(WTONTransfer)
 14947  	if err := _WTON.contract.UnpackLog(event, "Transfer", log); err != nil {
 14948  		return nil, err
 14949  	}
 14950  	return event, nil
 14951  }