ownership

package
v0.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 19, 2019 License: Apache-2.0 Imports: 8 Imported by: 0

Documentation

Index

Constants

View Source 
const AdminLockableABI = "" /* 2781-byte string literal not displayed */

AdminLockableABI is the input ABI used to generate the binding from.

View Source 
const AdminLockableBin = `` /* 4850-byte string literal not displayed */

AdminLockableBin is the compiled bytecode used for deploying new contracts.

View Source 
const AdministrableABI = "" /* 2275-byte string literal not displayed */

AdministrableABI is the input ABI used to generate the binding from.

View Source 
const AdministrableBin = `` /* 4126-byte string literal not displayed */

AdministrableBin is the compiled bytecode used for deploying new contracts.

View Source 
const OwnableABI = "" /* 1011-byte string literal not displayed */

OwnableABI is the input ABI used to generate the binding from.

View Source 
const OwnableBin = `` /* 1468-byte string literal not displayed */

OwnableBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

This section is empty.

Types

type AdminLockable 

type AdminLockable struct {
	AdminLockableCaller     // Read-only binding to the contract
	AdminLockableTransactor // Write-only binding to the contract
	AdminLockableFilterer   // Log filterer for contract events
}

AdminLockable is an auto generated Go binding around an Ethereum contract.

func DeployAdminLockable 

func DeployAdminLockable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *AdminLockable, error)

DeployAdminLockable deploys a new Ethereum contract, binding an instance of AdminLockable to it.

func NewAdminLockable 

func NewAdminLockable(address common.Address, backend bind.ContractBackend) (*AdminLockable, error)

NewAdminLockable creates a new instance of AdminLockable, bound to a specific deployed contract.

type AdminLockableAdminAdded 

type AdminLockableAdminAdded struct {
	Admin common.Address
	Raw   types.Log // Blockchain specific contextual infos
}

AdminLockableAdminAdded represents a AdminAdded event raised by the AdminLockable contract.

type AdminLockableAdminAddedIterator 

type AdminLockableAdminAddedIterator struct {
	Event *AdminLockableAdminAdded // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

AdminLockableAdminAddedIterator is returned from FilterAdminAdded and is used to iterate over the raw logs and unpacked data for AdminAdded events raised by the AdminLockable contract.

func (*AdminLockableAdminAddedIterator) Close 

func (it *AdminLockableAdminAddedIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*AdminLockableAdminAddedIterator) Error 

func (it *AdminLockableAdminAddedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*AdminLockableAdminAddedIterator) Next 

func (it *AdminLockableAdminAddedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type AdminLockableAdminRemoved 

type AdminLockableAdminRemoved struct {
	Admin common.Address
	Raw   types.Log // Blockchain specific contextual infos
}

AdminLockableAdminRemoved represents a AdminRemoved event raised by the AdminLockable contract.

type AdminLockableAdminRemovedIterator 

type AdminLockableAdminRemovedIterator struct {
	Event *AdminLockableAdminRemoved // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

AdminLockableAdminRemovedIterator is returned from FilterAdminRemoved and is used to iterate over the raw logs and unpacked data for AdminRemoved events raised by the AdminLockable contract.

func (*AdminLockableAdminRemovedIterator) Close 

func (it *AdminLockableAdminRemovedIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*AdminLockableAdminRemovedIterator) Error 

func (it *AdminLockableAdminRemovedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*AdminLockableAdminRemovedIterator) Next 

func (it *AdminLockableAdminRemovedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type AdminLockableCaller 

type AdminLockableCaller struct {
	// contains filtered or unexported fields
}

AdminLockableCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewAdminLockableCaller 

func NewAdminLockableCaller(address common.Address, caller bind.ContractCaller) (*AdminLockableCaller, error)

NewAdminLockableCaller creates a new read-only instance of AdminLockable, bound to a specific deployed contract.

func (*AdminLockableCaller) AdminAt added in v0.2.0 

func (_AdminLockable *AdminLockableCaller) AdminAt(opts *bind.CallOpts, index *big.Int) (common.Address, error)

AdminAt is a free data retrieval call binding the contract method 0x2bdbc56f.

Solidity: function adminAt(index int256) constant returns(address)

func (*AdminLockableCaller) Admins 

func (_AdminLockable *AdminLockableCaller) Admins(opts *bind.CallOpts) (*big.Int, error)

Admins is a free data retrieval call binding the contract method 0xa5de3619.

Solidity: function admins() constant returns(count int256)

func (*AdminLockableCaller) IsAdmin 

func (_AdminLockable *AdminLockableCaller) IsAdmin(opts *bind.CallOpts, addr common.Address) (bool, error)

IsAdmin is a free data retrieval call binding the contract method 0x24d7806c.

Solidity: function isAdmin(addr address) constant returns(bool)

func (*AdminLockableCaller) IsLocked 

func (_AdminLockable *AdminLockableCaller) IsLocked(opts *bind.CallOpts) (bool, error)

IsLocked is a free data retrieval call binding the contract method 0xa4e2d634.

Solidity: function isLocked() constant returns(bool)

func (*AdminLockableCaller) Owner 

func (_AdminLockable *AdminLockableCaller) Owner(opts *bind.CallOpts) (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*AdminLockableCaller) ZEROADDRESS added in v0.2.0 

func (_AdminLockable *AdminLockableCaller) ZEROADDRESS(opts *bind.CallOpts) (common.Address, error)

ZEROADDRESS is a free data retrieval call binding the contract method 0x538ba4f9.

Solidity: function ZERO_ADDRESS() constant returns(address)

type AdminLockableCallerRaw 

type AdminLockableCallerRaw struct {
	Contract *AdminLockableCaller // Generic read-only contract binding to access the raw methods on
}

AdminLockableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*AdminLockableCallerRaw) Call 

func (_AdminLockable *AdminLockableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type AdminLockableCallerSession 

type AdminLockableCallerSession struct {
	Contract *AdminLockableCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts        // Call options to use throughout this session
}

AdminLockableCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*AdminLockableCallerSession) AdminAt added in v0.2.0 

func (_AdminLockable *AdminLockableCallerSession) AdminAt(index *big.Int) (common.Address, error)

AdminAt is a free data retrieval call binding the contract method 0x2bdbc56f.

Solidity: function adminAt(index int256) constant returns(address)

func (*AdminLockableCallerSession) Admins 

func (_AdminLockable *AdminLockableCallerSession) Admins() (*big.Int, error)

Admins is a free data retrieval call binding the contract method 0xa5de3619.

Solidity: function admins() constant returns(count int256)

func (*AdminLockableCallerSession) IsAdmin 

func (_AdminLockable *AdminLockableCallerSession) IsAdmin(addr common.Address) (bool, error)

IsAdmin is a free data retrieval call binding the contract method 0x24d7806c.

Solidity: function isAdmin(addr address) constant returns(bool)

func (*AdminLockableCallerSession) IsLocked 

func (_AdminLockable *AdminLockableCallerSession) IsLocked() (bool, error)

IsLocked is a free data retrieval call binding the contract method 0xa4e2d634.

Solidity: function isLocked() constant returns(bool)

func (*AdminLockableCallerSession) Owner 

func (_AdminLockable *AdminLockableCallerSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*AdminLockableCallerSession) ZEROADDRESS added in v0.2.0 

func (_AdminLockable *AdminLockableCallerSession) ZEROADDRESS() (common.Address, error)

ZEROADDRESS is a free data retrieval call binding the contract method 0x538ba4f9.

Solidity: function ZERO_ADDRESS() constant returns(address)

type AdminLockableFilterer 

type AdminLockableFilterer struct {
	// contains filtered or unexported fields
}

AdminLockableFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewAdminLockableFilterer 

func NewAdminLockableFilterer(address common.Address, filterer bind.ContractFilterer) (*AdminLockableFilterer, error)

NewAdminLockableFilterer creates a new log filterer instance of AdminLockable, bound to a specific deployed contract.

func (*AdminLockableFilterer) FilterAdminAdded 

func (_AdminLockable *AdminLockableFilterer) FilterAdminAdded(opts *bind.FilterOpts, admin []common.Address) (*AdminLockableAdminAddedIterator, error)

FilterAdminAdded is a free log retrieval operation binding the contract event 0x44d6d25963f097ad14f29f06854a01f575648a1ef82f30e562ccd3889717e339.

Solidity: e AdminAdded(admin indexed address)

func (*AdminLockableFilterer) FilterAdminRemoved 

func (_AdminLockable *AdminLockableFilterer) FilterAdminRemoved(opts *bind.FilterOpts, admin []common.Address) (*AdminLockableAdminRemovedIterator, error)

FilterAdminRemoved is a free log retrieval operation binding the contract event 0xa3b62bc36326052d97ea62d63c3d60308ed4c3ea8ac079dd8499f1e9c4f80c0f.

Solidity: e AdminRemoved(admin indexed address)

func (*AdminLockableFilterer) FilterOwnerTransferred 

func (_AdminLockable *AdminLockableFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*AdminLockableOwnerTransferredIterator, error)

FilterOwnerTransferred is a free log retrieval operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

func (*AdminLockableFilterer) WatchAdminAdded 

func (_AdminLockable *AdminLockableFilterer) WatchAdminAdded(opts *bind.WatchOpts, sink chan<- *AdminLockableAdminAdded, admin []common.Address) (event.Subscription, error)

WatchAdminAdded is a free log subscription operation binding the contract event 0x44d6d25963f097ad14f29f06854a01f575648a1ef82f30e562ccd3889717e339.

Solidity: e AdminAdded(admin indexed address)

func (*AdminLockableFilterer) WatchAdminRemoved 

func (_AdminLockable *AdminLockableFilterer) WatchAdminRemoved(opts *bind.WatchOpts, sink chan<- *AdminLockableAdminRemoved, admin []common.Address) (event.Subscription, error)

WatchAdminRemoved is a free log subscription operation binding the contract event 0xa3b62bc36326052d97ea62d63c3d60308ed4c3ea8ac079dd8499f1e9c4f80c0f.

Solidity: e AdminRemoved(admin indexed address)

func (*AdminLockableFilterer) WatchOwnerTransferred 

func (_AdminLockable *AdminLockableFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *AdminLockableOwnerTransferred, oldOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnerTransferred is a free log subscription operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

type AdminLockableOwnerTransferred 

type AdminLockableOwnerTransferred struct {
	OldOwner common.Address
	NewOwner common.Address
	Raw      types.Log // Blockchain specific contextual infos
}

AdminLockableOwnerTransferred represents a OwnerTransferred event raised by the AdminLockable contract.

type AdminLockableOwnerTransferredIterator 

type AdminLockableOwnerTransferredIterator struct {
	Event *AdminLockableOwnerTransferred // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

AdminLockableOwnerTransferredIterator is returned from FilterOwnerTransferred and is used to iterate over the raw logs and unpacked data for OwnerTransferred events raised by the AdminLockable contract.

func (*AdminLockableOwnerTransferredIterator) Close 

func (it *AdminLockableOwnerTransferredIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*AdminLockableOwnerTransferredIterator) Error 

func (it *AdminLockableOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*AdminLockableOwnerTransferredIterator) Next 

func (it *AdminLockableOwnerTransferredIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type AdminLockableRaw 

type AdminLockableRaw struct {
	Contract *AdminLockable // Generic contract binding to access the raw methods on
}

AdminLockableRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*AdminLockableRaw) Call 

func (_AdminLockable *AdminLockableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*AdminLockableRaw) Transact 

func (_AdminLockable *AdminLockableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*AdminLockableRaw) Transfer 

func (_AdminLockable *AdminLockableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type AdminLockableSession 

type AdminLockableSession struct {
	Contract     *AdminLockable    // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

AdminLockableSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*AdminLockableSession) AdminAt added in v0.2.0 

func (_AdminLockable *AdminLockableSession) AdminAt(index *big.Int) (common.Address, error)

AdminAt is a free data retrieval call binding the contract method 0x2bdbc56f.

Solidity: function adminAt(index int256) constant returns(address)

func (*AdminLockableSession) Admins 

func (_AdminLockable *AdminLockableSession) Admins() (*big.Int, error)

Admins is a free data retrieval call binding the contract method 0xa5de3619.

Solidity: function admins() constant returns(count int256)

func (*AdminLockableSession) IsAdmin 

func (_AdminLockable *AdminLockableSession) IsAdmin(addr common.Address) (bool, error)

IsAdmin is a free data retrieval call binding the contract method 0x24d7806c.

Solidity: function isAdmin(addr address) constant returns(bool)

func (*AdminLockableSession) IsLocked 

func (_AdminLockable *AdminLockableSession) IsLocked() (bool, error)

IsLocked is a free data retrieval call binding the contract method 0xa4e2d634.

Solidity: function isLocked() constant returns(bool)

func (*AdminLockableSession) Owner 

func (_AdminLockable *AdminLockableSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*AdminLockableSession) SetAdmin added in v0.2.0 

func (_AdminLockable *AdminLockableSession) SetAdmin(addr common.Address, add bool) (*types.Transaction, error)

SetAdmin is a paid mutator transaction binding the contract method 0x4b0bddd2.

Solidity: function setAdmin(addr address, add bool) returns()

func (*AdminLockableSession) SetLocked 

func (_AdminLockable *AdminLockableSession) SetLocked(locked bool) (*types.Transaction, error)

SetLocked is a paid mutator transaction binding the contract method 0x211e28b6.

Solidity: function setLocked(locked bool) returns()

func (*AdminLockableSession) TransferOwner 

func (_AdminLockable *AdminLockableSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

func (*AdminLockableSession) ZEROADDRESS added in v0.2.0 

func (_AdminLockable *AdminLockableSession) ZEROADDRESS() (common.Address, error)

ZEROADDRESS is a free data retrieval call binding the contract method 0x538ba4f9.

Solidity: function ZERO_ADDRESS() constant returns(address)

type AdminLockableTransactor 

type AdminLockableTransactor struct {
	// contains filtered or unexported fields
}

AdminLockableTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewAdminLockableTransactor 

func NewAdminLockableTransactor(address common.Address, transactor bind.ContractTransactor) (*AdminLockableTransactor, error)

NewAdminLockableTransactor creates a new write-only instance of AdminLockable, bound to a specific deployed contract.

func (*AdminLockableTransactor) SetAdmin added in v0.2.0 

func (_AdminLockable *AdminLockableTransactor) SetAdmin(opts *bind.TransactOpts, addr common.Address, add bool) (*types.Transaction, error)

SetAdmin is a paid mutator transaction binding the contract method 0x4b0bddd2.

Solidity: function setAdmin(addr address, add bool) returns()

func (*AdminLockableTransactor) SetLocked 

func (_AdminLockable *AdminLockableTransactor) SetLocked(opts *bind.TransactOpts, locked bool) (*types.Transaction, error)

SetLocked is a paid mutator transaction binding the contract method 0x211e28b6.

Solidity: function setLocked(locked bool) returns()

func (*AdminLockableTransactor) TransferOwner 

func (_AdminLockable *AdminLockableTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type AdminLockableTransactorRaw 

type AdminLockableTransactorRaw struct {
	Contract *AdminLockableTransactor // Generic write-only contract binding to access the raw methods on
}

AdminLockableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*AdminLockableTransactorRaw) Transact 

func (_AdminLockable *AdminLockableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*AdminLockableTransactorRaw) Transfer 

func (_AdminLockable *AdminLockableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type AdminLockableTransactorSession 

type AdminLockableTransactorSession struct {
	Contract     *AdminLockableTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
}

AdminLockableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*AdminLockableTransactorSession) SetAdmin added in v0.2.0 

func (_AdminLockable *AdminLockableTransactorSession) SetAdmin(addr common.Address, add bool) (*types.Transaction, error)

SetAdmin is a paid mutator transaction binding the contract method 0x4b0bddd2.

Solidity: function setAdmin(addr address, add bool) returns()

func (*AdminLockableTransactorSession) SetLocked 

func (_AdminLockable *AdminLockableTransactorSession) SetLocked(locked bool) (*types.Transaction, error)

SetLocked is a paid mutator transaction binding the contract method 0x211e28b6.

Solidity: function setLocked(locked bool) returns()

func (*AdminLockableTransactorSession) TransferOwner 

func (_AdminLockable *AdminLockableTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type Administrable 

type Administrable struct {
	AdministrableCaller     // Read-only binding to the contract
	AdministrableTransactor // Write-only binding to the contract
	AdministrableFilterer   // Log filterer for contract events
}

Administrable is an auto generated Go binding around an Ethereum contract.

func DeployAdministrable 

func DeployAdministrable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Administrable, error)

DeployAdministrable deploys a new Ethereum contract, binding an instance of Administrable to it.

func NewAdministrable 

func NewAdministrable(address common.Address, backend bind.ContractBackend) (*Administrable, error)

NewAdministrable creates a new instance of Administrable, bound to a specific deployed contract.

type AdministrableAdminAdded 

type AdministrableAdminAdded struct {
	Admin common.Address
	Raw   types.Log // Blockchain specific contextual infos
}

AdministrableAdminAdded represents a AdminAdded event raised by the Administrable contract.

type AdministrableAdminAddedIterator 

type AdministrableAdminAddedIterator struct {
	Event *AdministrableAdminAdded // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

AdministrableAdminAddedIterator is returned from FilterAdminAdded and is used to iterate over the raw logs and unpacked data for AdminAdded events raised by the Administrable contract.

func (*AdministrableAdminAddedIterator) Close 

func (it *AdministrableAdminAddedIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*AdministrableAdminAddedIterator) Error 

func (it *AdministrableAdminAddedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*AdministrableAdminAddedIterator) Next 

func (it *AdministrableAdminAddedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type AdministrableAdminRemoved 

type AdministrableAdminRemoved struct {
	Admin common.Address
	Raw   types.Log // Blockchain specific contextual infos
}

AdministrableAdminRemoved represents a AdminRemoved event raised by the Administrable contract.

type AdministrableAdminRemovedIterator 

type AdministrableAdminRemovedIterator struct {
	Event *AdministrableAdminRemoved // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

AdministrableAdminRemovedIterator is returned from FilterAdminRemoved and is used to iterate over the raw logs and unpacked data for AdminRemoved events raised by the Administrable contract.

func (*AdministrableAdminRemovedIterator) Close 

func (it *AdministrableAdminRemovedIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*AdministrableAdminRemovedIterator) Error 

func (it *AdministrableAdminRemovedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*AdministrableAdminRemovedIterator) Next 

func (it *AdministrableAdminRemovedIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type AdministrableCaller 

type AdministrableCaller struct {
	// contains filtered or unexported fields
}

AdministrableCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewAdministrableCaller 

func NewAdministrableCaller(address common.Address, caller bind.ContractCaller) (*AdministrableCaller, error)

NewAdministrableCaller creates a new read-only instance of Administrable, bound to a specific deployed contract.

func (*AdministrableCaller) AdminAt added in v0.2.0 

func (_Administrable *AdministrableCaller) AdminAt(opts *bind.CallOpts, index *big.Int) (common.Address, error)

AdminAt is a free data retrieval call binding the contract method 0x2bdbc56f.

Solidity: function adminAt(index int256) constant returns(address)

func (*AdministrableCaller) Admins 

func (_Administrable *AdministrableCaller) Admins(opts *bind.CallOpts) (*big.Int, error)

Admins is a free data retrieval call binding the contract method 0xa5de3619.

Solidity: function admins() constant returns(count int256)

func (*AdministrableCaller) IsAdmin 

func (_Administrable *AdministrableCaller) IsAdmin(opts *bind.CallOpts, addr common.Address) (bool, error)

IsAdmin is a free data retrieval call binding the contract method 0x24d7806c.

Solidity: function isAdmin(addr address) constant returns(bool)

func (*AdministrableCaller) Owner 

func (_Administrable *AdministrableCaller) Owner(opts *bind.CallOpts) (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*AdministrableCaller) ZEROADDRESS added in v0.2.0 

func (_Administrable *AdministrableCaller) ZEROADDRESS(opts *bind.CallOpts) (common.Address, error)

ZEROADDRESS is a free data retrieval call binding the contract method 0x538ba4f9.

Solidity: function ZERO_ADDRESS() constant returns(address)

type AdministrableCallerRaw 

type AdministrableCallerRaw struct {
	Contract *AdministrableCaller // Generic read-only contract binding to access the raw methods on
}

AdministrableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*AdministrableCallerRaw) Call 

func (_Administrable *AdministrableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type AdministrableCallerSession 

type AdministrableCallerSession struct {
	Contract *AdministrableCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts        // Call options to use throughout this session
}

AdministrableCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*AdministrableCallerSession) AdminAt added in v0.2.0 

func (_Administrable *AdministrableCallerSession) AdminAt(index *big.Int) (common.Address, error)

AdminAt is a free data retrieval call binding the contract method 0x2bdbc56f.

Solidity: function adminAt(index int256) constant returns(address)

func (*AdministrableCallerSession) Admins 

func (_Administrable *AdministrableCallerSession) Admins() (*big.Int, error)

Admins is a free data retrieval call binding the contract method 0xa5de3619.

Solidity: function admins() constant returns(count int256)

func (*AdministrableCallerSession) IsAdmin 

func (_Administrable *AdministrableCallerSession) IsAdmin(addr common.Address) (bool, error)

IsAdmin is a free data retrieval call binding the contract method 0x24d7806c.

Solidity: function isAdmin(addr address) constant returns(bool)

func (*AdministrableCallerSession) Owner 

func (_Administrable *AdministrableCallerSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*AdministrableCallerSession) ZEROADDRESS added in v0.2.0 

func (_Administrable *AdministrableCallerSession) ZEROADDRESS() (common.Address, error)

ZEROADDRESS is a free data retrieval call binding the contract method 0x538ba4f9.

Solidity: function ZERO_ADDRESS() constant returns(address)

type AdministrableFilterer 

type AdministrableFilterer struct {
	// contains filtered or unexported fields
}

AdministrableFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewAdministrableFilterer 

func NewAdministrableFilterer(address common.Address, filterer bind.ContractFilterer) (*AdministrableFilterer, error)

NewAdministrableFilterer creates a new log filterer instance of Administrable, bound to a specific deployed contract.

func (*AdministrableFilterer) FilterAdminAdded 

func (_Administrable *AdministrableFilterer) FilterAdminAdded(opts *bind.FilterOpts, admin []common.Address) (*AdministrableAdminAddedIterator, error)

FilterAdminAdded is a free log retrieval operation binding the contract event 0x44d6d25963f097ad14f29f06854a01f575648a1ef82f30e562ccd3889717e339.

Solidity: e AdminAdded(admin indexed address)

func (*AdministrableFilterer) FilterAdminRemoved 

func (_Administrable *AdministrableFilterer) FilterAdminRemoved(opts *bind.FilterOpts, admin []common.Address) (*AdministrableAdminRemovedIterator, error)

FilterAdminRemoved is a free log retrieval operation binding the contract event 0xa3b62bc36326052d97ea62d63c3d60308ed4c3ea8ac079dd8499f1e9c4f80c0f.

Solidity: e AdminRemoved(admin indexed address)

func (*AdministrableFilterer) FilterOwnerTransferred 

func (_Administrable *AdministrableFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*AdministrableOwnerTransferredIterator, error)

FilterOwnerTransferred is a free log retrieval operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

func (*AdministrableFilterer) WatchAdminAdded 

func (_Administrable *AdministrableFilterer) WatchAdminAdded(opts *bind.WatchOpts, sink chan<- *AdministrableAdminAdded, admin []common.Address) (event.Subscription, error)

WatchAdminAdded is a free log subscription operation binding the contract event 0x44d6d25963f097ad14f29f06854a01f575648a1ef82f30e562ccd3889717e339.

Solidity: e AdminAdded(admin indexed address)

func (*AdministrableFilterer) WatchAdminRemoved 

func (_Administrable *AdministrableFilterer) WatchAdminRemoved(opts *bind.WatchOpts, sink chan<- *AdministrableAdminRemoved, admin []common.Address) (event.Subscription, error)

WatchAdminRemoved is a free log subscription operation binding the contract event 0xa3b62bc36326052d97ea62d63c3d60308ed4c3ea8ac079dd8499f1e9c4f80c0f.

Solidity: e AdminRemoved(admin indexed address)

func (*AdministrableFilterer) WatchOwnerTransferred 

func (_Administrable *AdministrableFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *AdministrableOwnerTransferred, oldOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnerTransferred is a free log subscription operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

type AdministrableOwnerTransferred 

type AdministrableOwnerTransferred struct {
	OldOwner common.Address
	NewOwner common.Address
	Raw      types.Log // Blockchain specific contextual infos
}

AdministrableOwnerTransferred represents a OwnerTransferred event raised by the Administrable contract.

type AdministrableOwnerTransferredIterator 

type AdministrableOwnerTransferredIterator struct {
	Event *AdministrableOwnerTransferred // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

AdministrableOwnerTransferredIterator is returned from FilterOwnerTransferred and is used to iterate over the raw logs and unpacked data for OwnerTransferred events raised by the Administrable contract.

func (*AdministrableOwnerTransferredIterator) Close 

func (it *AdministrableOwnerTransferredIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*AdministrableOwnerTransferredIterator) Error 

func (it *AdministrableOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*AdministrableOwnerTransferredIterator) Next 

func (it *AdministrableOwnerTransferredIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type AdministrableRaw 

type AdministrableRaw struct {
	Contract *Administrable // Generic contract binding to access the raw methods on
}

AdministrableRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*AdministrableRaw) Call 

func (_Administrable *AdministrableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*AdministrableRaw) Transact 

func (_Administrable *AdministrableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*AdministrableRaw) Transfer 

func (_Administrable *AdministrableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type AdministrableSession 

type AdministrableSession struct {
	Contract     *Administrable    // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

AdministrableSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*AdministrableSession) AdminAt added in v0.2.0 

func (_Administrable *AdministrableSession) AdminAt(index *big.Int) (common.Address, error)

AdminAt is a free data retrieval call binding the contract method 0x2bdbc56f.

Solidity: function adminAt(index int256) constant returns(address)

func (*AdministrableSession) Admins 

func (_Administrable *AdministrableSession) Admins() (*big.Int, error)

Admins is a free data retrieval call binding the contract method 0xa5de3619.

Solidity: function admins() constant returns(count int256)

func (*AdministrableSession) IsAdmin 

func (_Administrable *AdministrableSession) IsAdmin(addr common.Address) (bool, error)

IsAdmin is a free data retrieval call binding the contract method 0x24d7806c.

Solidity: function isAdmin(addr address) constant returns(bool)

func (*AdministrableSession) Owner 

func (_Administrable *AdministrableSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*AdministrableSession) SetAdmin added in v0.2.0 

func (_Administrable *AdministrableSession) SetAdmin(addr common.Address, add bool) (*types.Transaction, error)

SetAdmin is a paid mutator transaction binding the contract method 0x4b0bddd2.

Solidity: function setAdmin(addr address, add bool) returns()

func (*AdministrableSession) TransferOwner 

func (_Administrable *AdministrableSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

func (*AdministrableSession) ZEROADDRESS added in v0.2.0 

func (_Administrable *AdministrableSession) ZEROADDRESS() (common.Address, error)

ZEROADDRESS is a free data retrieval call binding the contract method 0x538ba4f9.

Solidity: function ZERO_ADDRESS() constant returns(address)

type AdministrableTransactor 

type AdministrableTransactor struct {
	// contains filtered or unexported fields
}

AdministrableTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewAdministrableTransactor 

func NewAdministrableTransactor(address common.Address, transactor bind.ContractTransactor) (*AdministrableTransactor, error)

NewAdministrableTransactor creates a new write-only instance of Administrable, bound to a specific deployed contract.

func (*AdministrableTransactor) SetAdmin added in v0.2.0 

func (_Administrable *AdministrableTransactor) SetAdmin(opts *bind.TransactOpts, addr common.Address, add bool) (*types.Transaction, error)

SetAdmin is a paid mutator transaction binding the contract method 0x4b0bddd2.

Solidity: function setAdmin(addr address, add bool) returns()

func (*AdministrableTransactor) TransferOwner 

func (_Administrable *AdministrableTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type AdministrableTransactorRaw 

type AdministrableTransactorRaw struct {
	Contract *AdministrableTransactor // Generic write-only contract binding to access the raw methods on
}

AdministrableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*AdministrableTransactorRaw) Transact 

func (_Administrable *AdministrableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*AdministrableTransactorRaw) Transfer 

func (_Administrable *AdministrableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type AdministrableTransactorSession 

type AdministrableTransactorSession struct {
	Contract     *AdministrableTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
}

AdministrableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*AdministrableTransactorSession) SetAdmin added in v0.2.0 

func (_Administrable *AdministrableTransactorSession) SetAdmin(addr common.Address, add bool) (*types.Transaction, error)

SetAdmin is a paid mutator transaction binding the contract method 0x4b0bddd2.

Solidity: function setAdmin(addr address, add bool) returns()

func (*AdministrableTransactorSession) TransferOwner 

func (_Administrable *AdministrableTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type Ownable 

type Ownable struct {
	OwnableCaller     // Read-only binding to the contract
	OwnableTransactor // Write-only binding to the contract
	OwnableFilterer   // Log filterer for contract events
}

Ownable is an auto generated Go binding around an Ethereum contract.

func DeployOwnable 

func DeployOwnable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Ownable, error)

DeployOwnable deploys a new Ethereum contract, binding an instance of Ownable to it.

func NewOwnable 

func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error)

NewOwnable creates a new instance of Ownable, bound to a specific deployed contract.

type OwnableCaller 

type OwnableCaller struct {
	// contains filtered or unexported fields
}

OwnableCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewOwnableCaller 

func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error)

NewOwnableCaller creates a new read-only instance of Ownable, bound to a specific deployed contract.

func (*OwnableCaller) Owner 

func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*OwnableCaller) ZEROADDRESS added in v0.2.0 

func (_Ownable *OwnableCaller) ZEROADDRESS(opts *bind.CallOpts) (common.Address, error)

ZEROADDRESS is a free data retrieval call binding the contract method 0x538ba4f9.

Solidity: function ZERO_ADDRESS() constant returns(address)

type OwnableCallerRaw 

type OwnableCallerRaw struct {
	Contract *OwnableCaller // Generic read-only contract binding to access the raw methods on
}

OwnableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*OwnableCallerRaw) Call 

func (_Ownable *OwnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

type OwnableCallerSession 

type OwnableCallerSession struct {
	Contract *OwnableCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts  // Call options to use throughout this session
}

OwnableCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

func (*OwnableCallerSession) Owner 

func (_Ownable *OwnableCallerSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*OwnableCallerSession) ZEROADDRESS added in v0.2.0 

func (_Ownable *OwnableCallerSession) ZEROADDRESS() (common.Address, error)

ZEROADDRESS is a free data retrieval call binding the contract method 0x538ba4f9.

Solidity: function ZERO_ADDRESS() constant returns(address)

type OwnableFilterer 

type OwnableFilterer struct {
	// contains filtered or unexported fields
}

OwnableFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewOwnableFilterer 

func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error)

NewOwnableFilterer creates a new log filterer instance of Ownable, bound to a specific deployed contract.

func (*OwnableFilterer) FilterOwnerTransferred 

func (_Ownable *OwnableFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*OwnableOwnerTransferredIterator, error)

FilterOwnerTransferred is a free log retrieval operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

func (*OwnableFilterer) WatchOwnerTransferred 

func (_Ownable *OwnableFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnerTransferred, oldOwner []common.Address, newOwner []common.Address) (event.Subscription, error)

WatchOwnerTransferred is a free log subscription operation binding the contract event 0x8934ce4adea8d9ce0d714d2c22b86790e41b7731c84b926fbbdc1d40ff6533c9.

Solidity: e OwnerTransferred(oldOwner indexed address, newOwner indexed address)

type OwnableOwnerTransferred 

type OwnableOwnerTransferred struct {
	OldOwner common.Address
	NewOwner common.Address
	Raw      types.Log // Blockchain specific contextual infos
}

OwnableOwnerTransferred represents a OwnerTransferred event raised by the Ownable contract.

type OwnableOwnerTransferredIterator 

type OwnableOwnerTransferredIterator struct {
	Event *OwnableOwnerTransferred // Event containing the contract specifics and raw log
	// contains filtered or unexported fields
}

OwnableOwnerTransferredIterator is returned from FilterOwnerTransferred and is used to iterate over the raw logs and unpacked data for OwnerTransferred events raised by the Ownable contract.

func (*OwnableOwnerTransferredIterator) Close 

func (it *OwnableOwnerTransferredIterator) Close() error

Close terminates the iteration process, releasing any pending underlying resources.

func (*OwnableOwnerTransferredIterator) Error 

func (it *OwnableOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*OwnableOwnerTransferredIterator) Next 

func (it *OwnableOwnerTransferredIterator) Next() bool

Next advances the iterator to the subsequent event, returning whether there are any more events found. In case of a retrieval or parsing error, false is returned and Error() can be queried for the exact failure.

type OwnableRaw 

type OwnableRaw struct {
	Contract *Ownable // Generic contract binding to access the raw methods on
}

OwnableRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*OwnableRaw) Call 

func (_Ownable *OwnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error

Call invokes the (constant) contract method with params as input values and sets the output to result. The result type might be a single field for simple returns, a slice of interfaces for anonymous returns and a struct for named returns.

func (*OwnableRaw) Transact 

func (_Ownable *OwnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*OwnableRaw) Transfer 

func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type OwnableSession 

type OwnableSession struct {
	Contract     *Ownable          // Generic contract binding to set the session for
	CallOpts     bind.CallOpts     // Call options to use throughout this session
	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
}

OwnableSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*OwnableSession) Owner 

func (_Ownable *OwnableSession) Owner() (common.Address, error)

Owner is a free data retrieval call binding the contract method 0x8da5cb5b.

Solidity: function owner() constant returns(address)

func (*OwnableSession) TransferOwner 

func (_Ownable *OwnableSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

func (*OwnableSession) ZEROADDRESS added in v0.2.0 

func (_Ownable *OwnableSession) ZEROADDRESS() (common.Address, error)

ZEROADDRESS is a free data retrieval call binding the contract method 0x538ba4f9.

Solidity: function ZERO_ADDRESS() constant returns(address)

type OwnableTransactor 

type OwnableTransactor struct {
	// contains filtered or unexported fields
}

OwnableTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewOwnableTransactor 

func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error)

NewOwnableTransactor creates a new write-only instance of Ownable, bound to a specific deployed contract.

func (*OwnableTransactor) TransferOwner 

func (_Ownable *OwnableTransactor) TransferOwner(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

type OwnableTransactorRaw 

type OwnableTransactorRaw struct {
	Contract *OwnableTransactor // Generic write-only contract binding to access the raw methods on
}

OwnableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*OwnableTransactorRaw) Transact 

func (_Ownable *OwnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*OwnableTransactorRaw) Transfer 

func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type OwnableTransactorSession 

type OwnableTransactorSession struct {
	Contract     *OwnableTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
}

OwnableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*OwnableTransactorSession) TransferOwner 

func (_Ownable *OwnableTransactorSession) TransferOwner(newOwner common.Address) (*types.Transaction, error)

TransferOwner is a paid mutator transaction binding the contract method 0x4fb2e45d.

Solidity: function transferOwner(newOwner address) returns()

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.