github.com/SmartMeshFoundation/Spectrum@v0.0.0-20220621030607-452a266fee1e/contracts/statute/meshboxlib/meshbox.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 meshboxlib
     5  
     6  import (
     7  	"math/big"
     8  	"strings"
     9  
    10  	"github.com/SmartMeshFoundation/Spectrum/accounts/abi"
    11  	"github.com/SmartMeshFoundation/Spectrum/accounts/abi/bind"
    12  	"github.com/SmartMeshFoundation/Spectrum/common"
    13  	"github.com/SmartMeshFoundation/Spectrum/core/types"
    14  )
    15  
    16  // MeshBoxABI is the input ABI used to generate the binding from.
    17  const MeshBoxABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"_owners\",\"type\":\"address[]\"}],\"name\":\"delAddress\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"existAddress\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_newOwner\",\"type\":\"address\"}],\"name\":\"changeOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_owners\",\"type\":\"address[]\"},{\"name\":\"version\",\"type\":\"uint256\"}],\"name\":\"addAddress\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"_prevOwner\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"_newOwner\",\"type\":\"address\"}],\"name\":\"OwnerUpdate\",\"type\":\"event\"}]"
    18  
    19  // MeshBoxBin is the compiled bytecode used for deploying new contracts.
    20  const MeshBoxBin = `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`
    21  
    22  // DeployMeshBox deploys a new Ethereum contract, binding an instance of MeshBox to it.
    23  func DeployMeshBox(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MeshBox, error) {
    24  	parsed, err := abi.JSON(strings.NewReader(MeshBoxABI))
    25  	if err != nil {
    26  		return common.Address{}, nil, nil, err
    27  	}
    28  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(MeshBoxBin), backend)
    29  	if err != nil {
    30  		return common.Address{}, nil, nil, err
    31  	}
    32  	return address, tx, &MeshBox{MeshBoxCaller: MeshBoxCaller{contract: contract}, MeshBoxTransactor: MeshBoxTransactor{contract: contract}}, nil
    33  }
    34  
    35  // MeshBox is an auto generated Go binding around an Ethereum contract.
    36  type MeshBox struct {
    37  	MeshBoxCaller     // Read-only binding to the contract
    38  	MeshBoxTransactor // Write-only binding to the contract
    39  }
    40  
    41  // MeshBoxCaller is an auto generated read-only Go binding around an Ethereum contract.
    42  type MeshBoxCaller struct {
    43  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
    44  }
    45  
    46  // MeshBoxTransactor is an auto generated write-only Go binding around an Ethereum contract.
    47  type MeshBoxTransactor struct {
    48  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
    49  }
    50  
    51  // MeshBoxSession is an auto generated Go binding around an Ethereum contract,
    52  // with pre-set call and transact options.
    53  type MeshBoxSession struct {
    54  	Contract     *MeshBox                // Generic contract binding to set the session for
    55  	CallOpts     bind.CallOptsWithNumber // Call options to use throughout this session
    56  	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
    57  }
    58  
    59  // MeshBoxCallerSession is an auto generated read-only Go binding around an Ethereum contract,
    60  // with pre-set call options.
    61  type MeshBoxCallerSession struct {
    62  	Contract *MeshBoxCaller          // Generic contract caller binding to set the session for
    63  	CallOpts bind.CallOptsWithNumber // Call options to use throughout this session
    64  }
    65  
    66  // MeshBoxTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
    67  // with pre-set transact options.
    68  type MeshBoxTransactorSession struct {
    69  	Contract     *MeshBoxTransactor // Generic contract transactor binding to set the session for
    70  	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
    71  }
    72  
    73  // MeshBoxRaw is an auto generated low-level Go binding around an Ethereum contract.
    74  type MeshBoxRaw struct {
    75  	Contract *MeshBox // Generic contract binding to access the raw methods on
    76  }
    77  
    78  // MeshBoxCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
    79  type MeshBoxCallerRaw struct {
    80  	Contract *MeshBoxCaller // Generic read-only contract binding to access the raw methods on
    81  }
    82  
    83  // MeshBoxTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
    84  type MeshBoxTransactorRaw struct {
    85  	Contract *MeshBoxTransactor // Generic write-only contract binding to access the raw methods on
    86  }
    87  
    88  // NewMeshBox creates a new instance of MeshBox, bound to a specific deployed contract.
    89  func NewMeshBox(address common.Address, backend bind.ContractBackend) (*MeshBox, error) {
    90  	contract, err := bindMeshBox(address, backend, backend)
    91  	if err != nil {
    92  		return nil, err
    93  	}
    94  	return &MeshBox{MeshBoxCaller: MeshBoxCaller{contract: contract}, MeshBoxTransactor: MeshBoxTransactor{contract: contract}}, nil
    95  }
    96  
    97  // NewMeshBoxCaller creates a new read-only instance of MeshBox, bound to a specific deployed contract.
    98  func NewMeshBoxCaller(address common.Address, caller bind.ContractCaller) (*MeshBoxCaller, error) {
    99  	contract, err := bindMeshBox(address, caller, nil)
   100  	if err != nil {
   101  		return nil, err
   102  	}
   103  	return &MeshBoxCaller{contract: contract}, nil
   104  }
   105  
   106  // NewMeshBoxTransactor creates a new write-only instance of MeshBox, bound to a specific deployed contract.
   107  func NewMeshBoxTransactor(address common.Address, transactor bind.ContractTransactor) (*MeshBoxTransactor, error) {
   108  	contract, err := bindMeshBox(address, nil, transactor)
   109  	if err != nil {
   110  		return nil, err
   111  	}
   112  	return &MeshBoxTransactor{contract: contract}, nil
   113  }
   114  
   115  // bindMeshBox binds a generic wrapper to an already deployed contract.
   116  func bindMeshBox(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {
   117  	parsed, err := abi.JSON(strings.NewReader(MeshBoxABI))
   118  	if err != nil {
   119  		return nil, err
   120  	}
   121  	return bind.NewBoundContract(address, parsed, caller, transactor), nil
   122  }
   123  
   124  // Call invokes the (constant) contract method with params as input values and
   125  // sets the output to result. The result type might be a single field for simple
   126  // returns, a slice of interfaces for anonymous returns and a struct for named
   127  // returns.
   128  func (_MeshBox *MeshBoxRaw) CallWithNumber(opts *bind.CallOptsWithNumber, result interface{}, method string, params ...interface{}) error {
   129  	return _MeshBox.Contract.MeshBoxCaller.contract.CallWithNumber(opts, result, method, params...)
   130  }
   131  
   132  // Transfer initiates a plain transaction to move funds to the contract, calling
   133  // its default method if one is available.
   134  func (_MeshBox *MeshBoxRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   135  	return _MeshBox.Contract.MeshBoxTransactor.contract.Transfer(opts)
   136  }
   137  
   138  // Transact invokes the (paid) contract method with params as input values.
   139  func (_MeshBox *MeshBoxRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   140  	return _MeshBox.Contract.MeshBoxTransactor.contract.Transact(opts, method, params...)
   141  }
   142  
   143  // Call invokes the (constant) contract method with params as input values and
   144  // sets the output to result. The result type might be a single field for simple
   145  // returns, a slice of interfaces for anonymous returns and a struct for named
   146  // returns.
   147  func (_MeshBox *MeshBoxCallerRaw) CallWithNumber(opts *bind.CallOptsWithNumber, result interface{}, method string, params ...interface{}) error {
   148  	return _MeshBox.Contract.contract.CallWithNumber(opts, result, method, params...)
   149  }
   150  
   151  // Transfer initiates a plain transaction to move funds to the contract, calling
   152  // its default method if one is available.
   153  func (_MeshBox *MeshBoxTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   154  	return _MeshBox.Contract.contract.Transfer(opts)
   155  }
   156  
   157  // Transact invokes the (paid) contract method with params as input values.
   158  func (_MeshBox *MeshBoxTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   159  	return _MeshBox.Contract.contract.Transact(opts, method, params...)
   160  }
   161  
   162  // ExistAddress is a free data retrieval call binding the contract method 0x80b7069d.
   163  //
   164  // Solidity: function existAddress(_owner address) constant returns(uint256)
   165  func (_MeshBox *MeshBoxCaller) ExistAddress(opts *bind.CallOptsWithNumber, _owner common.Address) (*big.Int, error) {
   166  	var (
   167  		ret0 = new(*big.Int)
   168  	)
   169  	out := ret0
   170  	err := _MeshBox.contract.CallWithNumber(opts, out, "existAddress", _owner)
   171  	return *ret0, err
   172  }
   173  
   174  // ExistAddress is a free data retrieval call binding the contract method 0x80b7069d.
   175  //
   176  // Solidity: function existAddress(_owner address) constant returns(uint256)
   177  func (_MeshBox *MeshBoxSession) ExistAddress(_owner common.Address) (*big.Int, error) {
   178  	return _MeshBox.Contract.ExistAddress(&_MeshBox.CallOpts, _owner)
   179  }
   180  
   181  // ExistAddress is a free data retrieval call binding the contract method 0x80b7069d.
   182  //
   183  // Solidity: function existAddress(_owner address) constant returns(uint256)
   184  func (_MeshBox *MeshBoxCallerSession) ExistAddress(_owner common.Address) (*big.Int, error) {
   185  	return _MeshBox.Contract.ExistAddress(&_MeshBox.CallOpts, _owner)
   186  }
   187  
   188  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
   189  //
   190  // Solidity: function owner() constant returns(address)
   191  func (_MeshBox *MeshBoxCaller) Owner(opts *bind.CallOptsWithNumber) (common.Address, error) {
   192  	var (
   193  		ret0 = new(common.Address)
   194  	)
   195  	out := ret0
   196  	err := _MeshBox.contract.CallWithNumber(opts, out, "owner")
   197  	return *ret0, err
   198  }
   199  
   200  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
   201  //
   202  // Solidity: function owner() constant returns(address)
   203  func (_MeshBox *MeshBoxSession) Owner() (common.Address, error) {
   204  	return _MeshBox.Contract.Owner(&_MeshBox.CallOpts)
   205  }
   206  
   207  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
   208  //
   209  // Solidity: function owner() constant returns(address)
   210  func (_MeshBox *MeshBoxCallerSession) Owner() (common.Address, error) {
   211  	return _MeshBox.Contract.Owner(&_MeshBox.CallOpts)
   212  }
   213  
   214  // AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
   215  //
   216  // Solidity: function acceptOwnership() returns()
   217  func (_MeshBox *MeshBoxTransactor) AcceptOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
   218  	return _MeshBox.contract.Transact(opts, "acceptOwnership")
   219  }
   220  
   221  // AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
   222  //
   223  // Solidity: function acceptOwnership() returns()
   224  func (_MeshBox *MeshBoxSession) AcceptOwnership() (*types.Transaction, error) {
   225  	return _MeshBox.Contract.AcceptOwnership(&_MeshBox.TransactOpts)
   226  }
   227  
   228  // AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
   229  //
   230  // Solidity: function acceptOwnership() returns()
   231  func (_MeshBox *MeshBoxTransactorSession) AcceptOwnership() (*types.Transaction, error) {
   232  	return _MeshBox.Contract.AcceptOwnership(&_MeshBox.TransactOpts)
   233  }
   234  
   235  // AddAddress is a paid mutator transaction binding the contract method 0xba4c18db.
   236  //
   237  // Solidity: function addAddress(_owners address[], version uint256) returns()
   238  func (_MeshBox *MeshBoxTransactor) AddAddress(opts *bind.TransactOpts, _owners []common.Address, version *big.Int) (*types.Transaction, error) {
   239  	return _MeshBox.contract.Transact(opts, "addAddress", _owners, version)
   240  }
   241  
   242  // AddAddress is a paid mutator transaction binding the contract method 0xba4c18db.
   243  //
   244  // Solidity: function addAddress(_owners address[], version uint256) returns()
   245  func (_MeshBox *MeshBoxSession) AddAddress(_owners []common.Address, version *big.Int) (*types.Transaction, error) {
   246  	return _MeshBox.Contract.AddAddress(&_MeshBox.TransactOpts, _owners, version)
   247  }
   248  
   249  // AddAddress is a paid mutator transaction binding the contract method 0xba4c18db.
   250  //
   251  // Solidity: function addAddress(_owners address[], version uint256) returns()
   252  func (_MeshBox *MeshBoxTransactorSession) AddAddress(_owners []common.Address, version *big.Int) (*types.Transaction, error) {
   253  	return _MeshBox.Contract.AddAddress(&_MeshBox.TransactOpts, _owners, version)
   254  }
   255  
   256  // ChangeOwner is a paid mutator transaction binding the contract method 0xa6f9dae1.
   257  //
   258  // Solidity: function changeOwner(_newOwner address) returns()
   259  func (_MeshBox *MeshBoxTransactor) ChangeOwner(opts *bind.TransactOpts, _newOwner common.Address) (*types.Transaction, error) {
   260  	return _MeshBox.contract.Transact(opts, "changeOwner", _newOwner)
   261  }
   262  
   263  // ChangeOwner is a paid mutator transaction binding the contract method 0xa6f9dae1.
   264  //
   265  // Solidity: function changeOwner(_newOwner address) returns()
   266  func (_MeshBox *MeshBoxSession) ChangeOwner(_newOwner common.Address) (*types.Transaction, error) {
   267  	return _MeshBox.Contract.ChangeOwner(&_MeshBox.TransactOpts, _newOwner)
   268  }
   269  
   270  // ChangeOwner is a paid mutator transaction binding the contract method 0xa6f9dae1.
   271  //
   272  // Solidity: function changeOwner(_newOwner address) returns()
   273  func (_MeshBox *MeshBoxTransactorSession) ChangeOwner(_newOwner common.Address) (*types.Transaction, error) {
   274  	return _MeshBox.Contract.ChangeOwner(&_MeshBox.TransactOpts, _newOwner)
   275  }
   276  
   277  // DelAddress is a paid mutator transaction binding the contract method 0x5022edf8.
   278  //
   279  // Solidity: function delAddress(_owners address[]) returns()
   280  func (_MeshBox *MeshBoxTransactor) DelAddress(opts *bind.TransactOpts, _owners []common.Address) (*types.Transaction, error) {
   281  	return _MeshBox.contract.Transact(opts, "delAddress", _owners)
   282  }
   283  
   284  // DelAddress is a paid mutator transaction binding the contract method 0x5022edf8.
   285  //
   286  // Solidity: function delAddress(_owners address[]) returns()
   287  func (_MeshBox *MeshBoxSession) DelAddress(_owners []common.Address) (*types.Transaction, error) {
   288  	return _MeshBox.Contract.DelAddress(&_MeshBox.TransactOpts, _owners)
   289  }
   290  
   291  // DelAddress is a paid mutator transaction binding the contract method 0x5022edf8.
   292  //
   293  // Solidity: function delAddress(_owners address[]) returns()
   294  func (_MeshBox *MeshBoxTransactorSession) DelAddress(_owners []common.Address) (*types.Transaction, error) {
   295  	return _MeshBox.Contract.DelAddress(&_MeshBox.TransactOpts, _owners)
   296  }
   297  
   298  // OwnedABI is the input ABI used to generate the binding from.
   299  const OwnedABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"acceptOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_newOwner\",\"type\":\"address\"}],\"name\":\"changeOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"_prevOwner\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"_newOwner\",\"type\":\"address\"}],\"name\":\"OwnerUpdate\",\"type\":\"event\"}]"
   300  
   301  // OwnedBin is the compiled bytecode used for deploying new contracts.
   302  const OwnedBin = `0x608060405260018054600160a060020a031916905534801561002057600080fd5b5060008054600160a060020a031916331790556101e9806100426000396000f3fe608060405234801561001057600080fd5b506004361061005d577c0100000000000000000000000000000000000000000000000000000000600035046379ba509781146100625780638da5cb5b1461006c578063a6f9dae114610090575b600080fd5b61006a6100b6565b005b61007461014d565b60408051600160a060020a039092168252519081900360200190f35b61006a600480360360208110156100a657600080fd5b5035600160a060020a031661015c565b600154600160a060020a031633146100cd57600080fd5b60005460015460408051600160a060020a03938416815292909116602083015280517f343765429aea5a34b3ff6a3785a98a5abb2597aca87bfbb58632c173d585373a9281900390910190a1600180546000805473ffffffffffffffffffffffffffffffffffffffff19908116600160a060020a03841617909155169055565b600054600160a060020a031681565b600054600160a060020a0316331461017357600080fd5b600054600160a060020a038281169116141561018e57600080fd5b6001805473ffffffffffffffffffffffffffffffffffffffff1916600160a060020a039290921691909117905556fea165627a7a7230582042576fa4333a57e21d2bfeeea4d8fa8673862f82ef805e512b1f34ce082646690029`
   303  
   304  // DeployOwned deploys a new Ethereum contract, binding an instance of Owned to it.
   305  func DeployOwned(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Owned, error) {
   306  	parsed, err := abi.JSON(strings.NewReader(OwnedABI))
   307  	if err != nil {
   308  		return common.Address{}, nil, nil, err
   309  	}
   310  	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(OwnedBin), backend)
   311  	if err != nil {
   312  		return common.Address{}, nil, nil, err
   313  	}
   314  	return address, tx, &Owned{OwnedCaller: OwnedCaller{contract: contract}, OwnedTransactor: OwnedTransactor{contract: contract}}, nil
   315  }
   316  
   317  // Owned is an auto generated Go binding around an Ethereum contract.
   318  type Owned struct {
   319  	OwnedCaller     // Read-only binding to the contract
   320  	OwnedTransactor // Write-only binding to the contract
   321  }
   322  
   323  // OwnedCaller is an auto generated read-only Go binding around an Ethereum contract.
   324  type OwnedCaller struct {
   325  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   326  }
   327  
   328  // OwnedTransactor is an auto generated write-only Go binding around an Ethereum contract.
   329  type OwnedTransactor struct {
   330  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
   331  }
   332  
   333  // OwnedSession is an auto generated Go binding around an Ethereum contract,
   334  // with pre-set call and transact options.
   335  type OwnedSession struct {
   336  	Contract     *Owned                  // Generic contract binding to set the session for
   337  	CallOpts     bind.CallOptsWithNumber // Call options to use throughout this session
   338  	TransactOpts bind.TransactOpts       // Transaction auth options to use throughout this session
   339  }
   340  
   341  // OwnedCallerSession is an auto generated read-only Go binding around an Ethereum contract,
   342  // with pre-set call options.
   343  type OwnedCallerSession struct {
   344  	Contract *OwnedCaller            // Generic contract caller binding to set the session for
   345  	CallOpts bind.CallOptsWithNumber // Call options to use throughout this session
   346  }
   347  
   348  // OwnedTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
   349  // with pre-set transact options.
   350  type OwnedTransactorSession struct {
   351  	Contract     *OwnedTransactor  // Generic contract transactor binding to set the session for
   352  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
   353  }
   354  
   355  // OwnedRaw is an auto generated low-level Go binding around an Ethereum contract.
   356  type OwnedRaw struct {
   357  	Contract *Owned // Generic contract binding to access the raw methods on
   358  }
   359  
   360  // OwnedCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
   361  type OwnedCallerRaw struct {
   362  	Contract *OwnedCaller // Generic read-only contract binding to access the raw methods on
   363  }
   364  
   365  // OwnedTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
   366  type OwnedTransactorRaw struct {
   367  	Contract *OwnedTransactor // Generic write-only contract binding to access the raw methods on
   368  }
   369  
   370  // NewOwned creates a new instance of Owned, bound to a specific deployed contract.
   371  func NewOwned(address common.Address, backend bind.ContractBackend) (*Owned, error) {
   372  	contract, err := bindOwned(address, backend, backend)
   373  	if err != nil {
   374  		return nil, err
   375  	}
   376  	return &Owned{OwnedCaller: OwnedCaller{contract: contract}, OwnedTransactor: OwnedTransactor{contract: contract}}, nil
   377  }
   378  
   379  // NewOwnedCaller creates a new read-only instance of Owned, bound to a specific deployed contract.
   380  func NewOwnedCaller(address common.Address, caller bind.ContractCaller) (*OwnedCaller, error) {
   381  	contract, err := bindOwned(address, caller, nil)
   382  	if err != nil {
   383  		return nil, err
   384  	}
   385  	return &OwnedCaller{contract: contract}, nil
   386  }
   387  
   388  // NewOwnedTransactor creates a new write-only instance of Owned, bound to a specific deployed contract.
   389  func NewOwnedTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnedTransactor, error) {
   390  	contract, err := bindOwned(address, nil, transactor)
   391  	if err != nil {
   392  		return nil, err
   393  	}
   394  	return &OwnedTransactor{contract: contract}, nil
   395  }
   396  
   397  // bindOwned binds a generic wrapper to an already deployed contract.
   398  func bindOwned(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {
   399  	parsed, err := abi.JSON(strings.NewReader(OwnedABI))
   400  	if err != nil {
   401  		return nil, err
   402  	}
   403  	return bind.NewBoundContract(address, parsed, caller, transactor), nil
   404  }
   405  
   406  // Call invokes the (constant) contract method with params as input values and
   407  // sets the output to result. The result type might be a single field for simple
   408  // returns, a slice of interfaces for anonymous returns and a struct for named
   409  // returns.
   410  func (_Owned *OwnedRaw) CallWithNumber(opts *bind.CallOptsWithNumber, result interface{}, method string, params ...interface{}) error {
   411  	return _Owned.Contract.OwnedCaller.contract.CallWithNumber(opts, result, method, params...)
   412  }
   413  
   414  // Transfer initiates a plain transaction to move funds to the contract, calling
   415  // its default method if one is available.
   416  func (_Owned *OwnedRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   417  	return _Owned.Contract.OwnedTransactor.contract.Transfer(opts)
   418  }
   419  
   420  // Transact invokes the (paid) contract method with params as input values.
   421  func (_Owned *OwnedRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   422  	return _Owned.Contract.OwnedTransactor.contract.Transact(opts, method, params...)
   423  }
   424  
   425  // Call invokes the (constant) contract method with params as input values and
   426  // sets the output to result. The result type might be a single field for simple
   427  // returns, a slice of interfaces for anonymous returns and a struct for named
   428  // returns.
   429  func (_Owned *OwnedCallerRaw) CallWithNumber(opts *bind.CallOptsWithNumber, result interface{}, method string, params ...interface{}) error {
   430  	return _Owned.Contract.contract.CallWithNumber(opts, result, method, params...)
   431  }
   432  
   433  // Transfer initiates a plain transaction to move funds to the contract, calling
   434  // its default method if one is available.
   435  func (_Owned *OwnedTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   436  	return _Owned.Contract.contract.Transfer(opts)
   437  }
   438  
   439  // Transact invokes the (paid) contract method with params as input values.
   440  func (_Owned *OwnedTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   441  	return _Owned.Contract.contract.Transact(opts, method, params...)
   442  }
   443  
   444  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
   445  //
   446  // Solidity: function owner() constant returns(address)
   447  func (_Owned *OwnedCaller) Owner(opts *bind.CallOptsWithNumber) (common.Address, error) {
   448  	var (
   449  		ret0 = new(common.Address)
   450  	)
   451  	out := ret0
   452  	err := _Owned.contract.CallWithNumber(opts, out, "owner")
   453  	return *ret0, err
   454  }
   455  
   456  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
   457  //
   458  // Solidity: function owner() constant returns(address)
   459  func (_Owned *OwnedSession) Owner() (common.Address, error) {
   460  	return _Owned.Contract.Owner(&_Owned.CallOpts)
   461  }
   462  
   463  // Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
   464  //
   465  // Solidity: function owner() constant returns(address)
   466  func (_Owned *OwnedCallerSession) Owner() (common.Address, error) {
   467  	return _Owned.Contract.Owner(&_Owned.CallOpts)
   468  }
   469  
   470  // AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
   471  //
   472  // Solidity: function acceptOwnership() returns()
   473  func (_Owned *OwnedTransactor) AcceptOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
   474  	return _Owned.contract.Transact(opts, "acceptOwnership")
   475  }
   476  
   477  // AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
   478  //
   479  // Solidity: function acceptOwnership() returns()
   480  func (_Owned *OwnedSession) AcceptOwnership() (*types.Transaction, error) {
   481  	return _Owned.Contract.AcceptOwnership(&_Owned.TransactOpts)
   482  }
   483  
   484  // AcceptOwnership is a paid mutator transaction binding the contract method 0x79ba5097.
   485  //
   486  // Solidity: function acceptOwnership() returns()
   487  func (_Owned *OwnedTransactorSession) AcceptOwnership() (*types.Transaction, error) {
   488  	return _Owned.Contract.AcceptOwnership(&_Owned.TransactOpts)
   489  }
   490  
   491  // ChangeOwner is a paid mutator transaction binding the contract method 0xa6f9dae1.
   492  //
   493  // Solidity: function changeOwner(_newOwner address) returns()
   494  func (_Owned *OwnedTransactor) ChangeOwner(opts *bind.TransactOpts, _newOwner common.Address) (*types.Transaction, error) {
   495  	return _Owned.contract.Transact(opts, "changeOwner", _newOwner)
   496  }
   497  
   498  // ChangeOwner is a paid mutator transaction binding the contract method 0xa6f9dae1.
   499  //
   500  // Solidity: function changeOwner(_newOwner address) returns()
   501  func (_Owned *OwnedSession) ChangeOwner(_newOwner common.Address) (*types.Transaction, error) {
   502  	return _Owned.Contract.ChangeOwner(&_Owned.TransactOpts, _newOwner)
   503  }
   504  
   505  // ChangeOwner is a paid mutator transaction binding the contract method 0xa6f9dae1.
   506  //
   507  // Solidity: function changeOwner(_newOwner address) returns()
   508  func (_Owned *OwnedTransactorSession) ChangeOwner(_newOwner common.Address) (*types.Transaction, error) {
   509  	return _Owned.Contract.ChangeOwner(&_Owned.TransactOpts, _newOwner)
   510  }