lifecycle

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 AdminLockableDestroyableABI = "" /* 2830-byte string literal not displayed */

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

View Source 
const AdminLockableDestroyableBin = `` /* 5158-byte string literal not displayed */

AdminLockableDestroyableBin is the compiled bytecode used for deploying new contracts.

View Source 
const CloneableABI = "" /* 213-byte string literal not displayed */

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

View Source 
const CloneableBin = `` /* 456-byte string literal not displayed */

CloneableBin is the compiled bytecode used for deploying new contracts.

View Source 
const DestroyableABI = "" /* 1060-byte string literal not displayed */

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

View Source 
const DestroyableBin = `` /* 1744-byte string literal not displayed */

DestroyableBin is the compiled bytecode used for deploying new contracts.

View Source 
const LockableABI = "" /* 1423-byte string literal not displayed */

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

View Source 
const LockableBin = `` /* 2318-byte string literal not displayed */

LockableBin is the compiled bytecode used for deploying new contracts.

View Source 
const LockableDestroyableABI = "" /* 1472-byte string literal not displayed */

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

View Source 
const LockableDestroyableBin = `` /* 2576-byte string literal not displayed */

LockableDestroyableBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

This section is empty.

Types

type AdminLockableDestroyable 

type AdminLockableDestroyable struct {
	AdminLockableDestroyableCaller     // Read-only binding to the contract
	AdminLockableDestroyableTransactor // Write-only binding to the contract
	AdminLockableDestroyableFilterer   // Log filterer for contract events
}

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

func DeployAdminLockableDestroyable 

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

DeployAdminLockableDestroyable deploys a new Ethereum contract, binding an instance of AdminLockableDestroyable to it.

func NewAdminLockableDestroyable 

func NewAdminLockableDestroyable(address common.Address, backend bind.ContractBackend) (*AdminLockableDestroyable, error)

NewAdminLockableDestroyable creates a new instance of AdminLockableDestroyable, bound to a specific deployed contract.

type AdminLockableDestroyableAdminAdded 

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

AdminLockableDestroyableAdminAdded represents a AdminAdded event raised by the AdminLockableDestroyable contract.

type AdminLockableDestroyableAdminAddedIterator 

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

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

func (*AdminLockableDestroyableAdminAddedIterator) Close 

func (it *AdminLockableDestroyableAdminAddedIterator) Close() error

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

func (*AdminLockableDestroyableAdminAddedIterator) Error 

func (it *AdminLockableDestroyableAdminAddedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*AdminLockableDestroyableAdminAddedIterator) Next 

func (it *AdminLockableDestroyableAdminAddedIterator) 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 AdminLockableDestroyableAdminRemoved 

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

AdminLockableDestroyableAdminRemoved represents a AdminRemoved event raised by the AdminLockableDestroyable contract.

type AdminLockableDestroyableAdminRemovedIterator 

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

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

func (*AdminLockableDestroyableAdminRemovedIterator) Close 

func (it *AdminLockableDestroyableAdminRemovedIterator) Close() error

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

func (*AdminLockableDestroyableAdminRemovedIterator) Error 

func (it *AdminLockableDestroyableAdminRemovedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*AdminLockableDestroyableAdminRemovedIterator) Next 

func (it *AdminLockableDestroyableAdminRemovedIterator) 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 AdminLockableDestroyableCaller 

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

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

func NewAdminLockableDestroyableCaller 

func NewAdminLockableDestroyableCaller(address common.Address, caller bind.ContractCaller) (*AdminLockableDestroyableCaller, error)

NewAdminLockableDestroyableCaller creates a new read-only instance of AdminLockableDestroyable, bound to a specific deployed contract.

func (*AdminLockableDestroyableCaller) AdminAt added in v0.2.0 

func (_AdminLockableDestroyable *AdminLockableDestroyableCaller) 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 (*AdminLockableDestroyableCaller) Admins 

func (_AdminLockableDestroyable *AdminLockableDestroyableCaller) 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 (*AdminLockableDestroyableCaller) IsAdmin 

func (_AdminLockableDestroyable *AdminLockableDestroyableCaller) 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 (*AdminLockableDestroyableCaller) IsLocked 

func (_AdminLockableDestroyable *AdminLockableDestroyableCaller) 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 (*AdminLockableDestroyableCaller) Owner 

func (_AdminLockableDestroyable *AdminLockableDestroyableCaller) 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 (*AdminLockableDestroyableCaller) ZEROADDRESS added in v0.2.0 

func (_AdminLockableDestroyable *AdminLockableDestroyableCaller) 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 AdminLockableDestroyableCallerRaw 

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

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

func (*AdminLockableDestroyableCallerRaw) Call 

func (_AdminLockableDestroyable *AdminLockableDestroyableCallerRaw) 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 AdminLockableDestroyableCallerSession 

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

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

func (*AdminLockableDestroyableCallerSession) AdminAt added in v0.2.0 

func (_AdminLockableDestroyable *AdminLockableDestroyableCallerSession) 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 (*AdminLockableDestroyableCallerSession) Admins 

func (_AdminLockableDestroyable *AdminLockableDestroyableCallerSession) Admins() (*big.Int, error)

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

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

func (*AdminLockableDestroyableCallerSession) IsAdmin 

func (_AdminLockableDestroyable *AdminLockableDestroyableCallerSession) 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 (*AdminLockableDestroyableCallerSession) IsLocked 

func (_AdminLockableDestroyable *AdminLockableDestroyableCallerSession) IsLocked() (bool, error)

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

Solidity: function isLocked() constant returns(bool)

func (*AdminLockableDestroyableCallerSession) Owner 

func (_AdminLockableDestroyable *AdminLockableDestroyableCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*AdminLockableDestroyableCallerSession) ZEROADDRESS added in v0.2.0 

func (_AdminLockableDestroyable *AdminLockableDestroyableCallerSession) ZEROADDRESS() (common.Address, error)

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

Solidity: function ZERO_ADDRESS() constant returns(address)

type AdminLockableDestroyableFilterer 

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

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

func NewAdminLockableDestroyableFilterer 

func NewAdminLockableDestroyableFilterer(address common.Address, filterer bind.ContractFilterer) (*AdminLockableDestroyableFilterer, error)

NewAdminLockableDestroyableFilterer creates a new log filterer instance of AdminLockableDestroyable, bound to a specific deployed contract.

func (*AdminLockableDestroyableFilterer) FilterAdminAdded 

func (_AdminLockableDestroyable *AdminLockableDestroyableFilterer) FilterAdminAdded(opts *bind.FilterOpts, admin []common.Address) (*AdminLockableDestroyableAdminAddedIterator, error)

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

Solidity: e AdminAdded(admin indexed address)

func (*AdminLockableDestroyableFilterer) FilterAdminRemoved 

func (_AdminLockableDestroyable *AdminLockableDestroyableFilterer) FilterAdminRemoved(opts *bind.FilterOpts, admin []common.Address) (*AdminLockableDestroyableAdminRemovedIterator, error)

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

Solidity: e AdminRemoved(admin indexed address)

func (*AdminLockableDestroyableFilterer) FilterOwnerTransferred 

func (_AdminLockableDestroyable *AdminLockableDestroyableFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*AdminLockableDestroyableOwnerTransferredIterator, error)

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

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

func (*AdminLockableDestroyableFilterer) WatchAdminAdded 

func (_AdminLockableDestroyable *AdminLockableDestroyableFilterer) WatchAdminAdded(opts *bind.WatchOpts, sink chan<- *AdminLockableDestroyableAdminAdded, 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 (*AdminLockableDestroyableFilterer) WatchAdminRemoved 

func (_AdminLockableDestroyable *AdminLockableDestroyableFilterer) WatchAdminRemoved(opts *bind.WatchOpts, sink chan<- *AdminLockableDestroyableAdminRemoved, 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 (*AdminLockableDestroyableFilterer) WatchOwnerTransferred 

func (_AdminLockableDestroyable *AdminLockableDestroyableFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *AdminLockableDestroyableOwnerTransferred, 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 AdminLockableDestroyableOwnerTransferred 

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

AdminLockableDestroyableOwnerTransferred represents a OwnerTransferred event raised by the AdminLockableDestroyable contract.

type AdminLockableDestroyableOwnerTransferredIterator 

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

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

func (*AdminLockableDestroyableOwnerTransferredIterator) Close 

func (it *AdminLockableDestroyableOwnerTransferredIterator) Close() error

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

func (*AdminLockableDestroyableOwnerTransferredIterator) Error 

func (it *AdminLockableDestroyableOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*AdminLockableDestroyableOwnerTransferredIterator) Next 

func (it *AdminLockableDestroyableOwnerTransferredIterator) 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 AdminLockableDestroyableRaw 

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

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

func (*AdminLockableDestroyableRaw) Call 

func (_AdminLockableDestroyable *AdminLockableDestroyableRaw) 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 (*AdminLockableDestroyableRaw) Transact 

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

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

func (*AdminLockableDestroyableRaw) Transfer 

func (_AdminLockableDestroyable *AdminLockableDestroyableRaw) 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 AdminLockableDestroyableSession 

type AdminLockableDestroyableSession struct {
	Contract     *AdminLockableDestroyable // 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
}

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

func (*AdminLockableDestroyableSession) AdminAt added in v0.2.0 

func (_AdminLockableDestroyable *AdminLockableDestroyableSession) 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 (*AdminLockableDestroyableSession) Admins 

func (_AdminLockableDestroyable *AdminLockableDestroyableSession) Admins() (*big.Int, error)

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

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

func (*AdminLockableDestroyableSession) IsAdmin 

func (_AdminLockableDestroyable *AdminLockableDestroyableSession) 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 (*AdminLockableDestroyableSession) IsLocked 

func (_AdminLockableDestroyable *AdminLockableDestroyableSession) IsLocked() (bool, error)

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

Solidity: function isLocked() constant returns(bool)

func (*AdminLockableDestroyableSession) Kill 

func (_AdminLockableDestroyable *AdminLockableDestroyableSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*AdminLockableDestroyableSession) Owner 

func (_AdminLockableDestroyable *AdminLockableDestroyableSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*AdminLockableDestroyableSession) SetAdmin added in v0.2.0 

func (_AdminLockableDestroyable *AdminLockableDestroyableSession) 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 (*AdminLockableDestroyableSession) SetLocked 

func (_AdminLockableDestroyable *AdminLockableDestroyableSession) SetLocked(locked bool) (*types.Transaction, error)

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

Solidity: function setLocked(locked bool) returns()

func (*AdminLockableDestroyableSession) TransferOwner 

func (_AdminLockableDestroyable *AdminLockableDestroyableSession) 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 (*AdminLockableDestroyableSession) ZEROADDRESS added in v0.2.0 

func (_AdminLockableDestroyable *AdminLockableDestroyableSession) ZEROADDRESS() (common.Address, error)

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

Solidity: function ZERO_ADDRESS() constant returns(address)

type AdminLockableDestroyableTransactor 

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

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

func NewAdminLockableDestroyableTransactor 

func NewAdminLockableDestroyableTransactor(address common.Address, transactor bind.ContractTransactor) (*AdminLockableDestroyableTransactor, error)

NewAdminLockableDestroyableTransactor creates a new write-only instance of AdminLockableDestroyable, bound to a specific deployed contract.

func (*AdminLockableDestroyableTransactor) Kill 

func (_AdminLockableDestroyable *AdminLockableDestroyableTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*AdminLockableDestroyableTransactor) SetAdmin added in v0.2.0 

func (_AdminLockableDestroyable *AdminLockableDestroyableTransactor) 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 (*AdminLockableDestroyableTransactor) SetLocked 

func (_AdminLockableDestroyable *AdminLockableDestroyableTransactor) 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 (*AdminLockableDestroyableTransactor) TransferOwner 

func (_AdminLockableDestroyable *AdminLockableDestroyableTransactor) 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 AdminLockableDestroyableTransactorRaw 

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

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

func (*AdminLockableDestroyableTransactorRaw) Transact 

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

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

func (*AdminLockableDestroyableTransactorRaw) Transfer 

func (_AdminLockableDestroyable *AdminLockableDestroyableTransactorRaw) 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 AdminLockableDestroyableTransactorSession 

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

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

func (*AdminLockableDestroyableTransactorSession) Kill 

func (_AdminLockableDestroyable *AdminLockableDestroyableTransactorSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*AdminLockableDestroyableTransactorSession) SetAdmin added in v0.2.0 

func (_AdminLockableDestroyable *AdminLockableDestroyableTransactorSession) 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 (*AdminLockableDestroyableTransactorSession) SetLocked 

func (_AdminLockableDestroyable *AdminLockableDestroyableTransactorSession) SetLocked(locked bool) (*types.Transaction, error)

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

Solidity: function setLocked(locked bool) returns()

func (*AdminLockableDestroyableTransactorSession) TransferOwner 

func (_AdminLockableDestroyable *AdminLockableDestroyableTransactorSession) 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 Cloneable added in v0.2.0 

type Cloneable struct {
	CloneableCaller     // Read-only binding to the contract
	CloneableTransactor // Write-only binding to the contract
	CloneableFilterer   // Log filterer for contract events
}

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

func DeployCloneable added in v0.2.0 

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

DeployCloneable deploys a new Ethereum contract, binding an instance of Cloneable to it.

func NewCloneable added in v0.2.0 

func NewCloneable(address common.Address, backend bind.ContractBackend) (*Cloneable, error)

NewCloneable creates a new instance of Cloneable, bound to a specific deployed contract.

type CloneableCaller added in v0.2.0 

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

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

func NewCloneableCaller added in v0.2.0 

func NewCloneableCaller(address common.Address, caller bind.ContractCaller) (*CloneableCaller, error)

NewCloneableCaller creates a new read-only instance of Cloneable, bound to a specific deployed contract.

type CloneableCallerRaw added in v0.2.0 

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

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

func (*CloneableCallerRaw) Call added in v0.2.0 

func (_Cloneable *CloneableCallerRaw) 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 CloneableCallerSession added in v0.2.0 

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

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

type CloneableFilterer added in v0.2.0 

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

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

func NewCloneableFilterer added in v0.2.0 

func NewCloneableFilterer(address common.Address, filterer bind.ContractFilterer) (*CloneableFilterer, error)

NewCloneableFilterer creates a new log filterer instance of Cloneable, bound to a specific deployed contract.

type CloneableRaw added in v0.2.0 

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

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

func (*CloneableRaw) Call added in v0.2.0 

func (_Cloneable *CloneableRaw) 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 (*CloneableRaw) Transact added in v0.2.0 

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

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

func (*CloneableRaw) Transfer added in v0.2.0 

func (_Cloneable *CloneableRaw) 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 CloneableSession added in v0.2.0 

type CloneableSession struct {
	Contract     *Cloneable        // 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
}

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

func (*CloneableSession) Clone added in v0.2.0 

func (_Cloneable *CloneableSession) Clone() (*types.Transaction, error)

Clone is a paid mutator transaction binding the contract method 0x09ed4607.

Solidity: function clone() returns(address)

type CloneableTransactor added in v0.2.0 

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

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

func NewCloneableTransactor added in v0.2.0 

func NewCloneableTransactor(address common.Address, transactor bind.ContractTransactor) (*CloneableTransactor, error)

NewCloneableTransactor creates a new write-only instance of Cloneable, bound to a specific deployed contract.

func (*CloneableTransactor) Clone added in v0.2.0 

func (_Cloneable *CloneableTransactor) Clone(opts *bind.TransactOpts) (*types.Transaction, error)

Clone is a paid mutator transaction binding the contract method 0x09ed4607.

Solidity: function clone() returns(address)

type CloneableTransactorRaw added in v0.2.0 

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

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

func (*CloneableTransactorRaw) Transact added in v0.2.0 

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

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

func (*CloneableTransactorRaw) Transfer added in v0.2.0 

func (_Cloneable *CloneableTransactorRaw) 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 CloneableTransactorSession added in v0.2.0 

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

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

func (*CloneableTransactorSession) Clone added in v0.2.0 

func (_Cloneable *CloneableTransactorSession) Clone() (*types.Transaction, error)

Clone is a paid mutator transaction binding the contract method 0x09ed4607.

Solidity: function clone() returns(address)

type Destroyable 

type Destroyable struct {
	DestroyableCaller     // Read-only binding to the contract
	DestroyableTransactor // Write-only binding to the contract
	DestroyableFilterer   // Log filterer for contract events
}

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

func DeployDestroyable 

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

DeployDestroyable deploys a new Ethereum contract, binding an instance of Destroyable to it.

func NewDestroyable 

func NewDestroyable(address common.Address, backend bind.ContractBackend) (*Destroyable, error)

NewDestroyable creates a new instance of Destroyable, bound to a specific deployed contract.

type DestroyableCaller 

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

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

func NewDestroyableCaller 

func NewDestroyableCaller(address common.Address, caller bind.ContractCaller) (*DestroyableCaller, error)

NewDestroyableCaller creates a new read-only instance of Destroyable, bound to a specific deployed contract.

func (*DestroyableCaller) Owner 

func (_Destroyable *DestroyableCaller) 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 (*DestroyableCaller) ZEROADDRESS added in v0.2.0 

func (_Destroyable *DestroyableCaller) 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 DestroyableCallerRaw 

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

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

func (*DestroyableCallerRaw) Call 

func (_Destroyable *DestroyableCallerRaw) 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 DestroyableCallerSession 

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

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

func (*DestroyableCallerSession) Owner 

func (_Destroyable *DestroyableCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*DestroyableCallerSession) ZEROADDRESS added in v0.2.0 

func (_Destroyable *DestroyableCallerSession) ZEROADDRESS() (common.Address, error)

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

Solidity: function ZERO_ADDRESS() constant returns(address)

type DestroyableFilterer 

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

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

func NewDestroyableFilterer 

func NewDestroyableFilterer(address common.Address, filterer bind.ContractFilterer) (*DestroyableFilterer, error)

NewDestroyableFilterer creates a new log filterer instance of Destroyable, bound to a specific deployed contract.

func (*DestroyableFilterer) FilterOwnerTransferred 

func (_Destroyable *DestroyableFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*DestroyableOwnerTransferredIterator, error)

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

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

func (*DestroyableFilterer) WatchOwnerTransferred 

func (_Destroyable *DestroyableFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *DestroyableOwnerTransferred, 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 DestroyableOwnerTransferred 

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

DestroyableOwnerTransferred represents a OwnerTransferred event raised by the Destroyable contract.

type DestroyableOwnerTransferredIterator 

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

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

func (*DestroyableOwnerTransferredIterator) Close 

func (it *DestroyableOwnerTransferredIterator) Close() error

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

func (*DestroyableOwnerTransferredIterator) Error 

func (it *DestroyableOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DestroyableOwnerTransferredIterator) Next 

func (it *DestroyableOwnerTransferredIterator) 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 DestroyableRaw 

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

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

func (*DestroyableRaw) Call 

func (_Destroyable *DestroyableRaw) 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 (*DestroyableRaw) Transact 

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

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

func (*DestroyableRaw) Transfer 

func (_Destroyable *DestroyableRaw) 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 DestroyableSession 

type DestroyableSession struct {
	Contract     *Destroyable      // 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
}

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

func (*DestroyableSession) Kill 

func (_Destroyable *DestroyableSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*DestroyableSession) Owner 

func (_Destroyable *DestroyableSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*DestroyableSession) TransferOwner 

func (_Destroyable *DestroyableSession) 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 (*DestroyableSession) ZEROADDRESS added in v0.2.0 

func (_Destroyable *DestroyableSession) ZEROADDRESS() (common.Address, error)

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

Solidity: function ZERO_ADDRESS() constant returns(address)

type DestroyableTransactor 

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

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

func NewDestroyableTransactor 

func NewDestroyableTransactor(address common.Address, transactor bind.ContractTransactor) (*DestroyableTransactor, error)

NewDestroyableTransactor creates a new write-only instance of Destroyable, bound to a specific deployed contract.

func (*DestroyableTransactor) Kill 

func (_Destroyable *DestroyableTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*DestroyableTransactor) TransferOwner 

func (_Destroyable *DestroyableTransactor) 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 DestroyableTransactorRaw 

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

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

func (*DestroyableTransactorRaw) Transact 

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

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

func (*DestroyableTransactorRaw) Transfer 

func (_Destroyable *DestroyableTransactorRaw) 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 DestroyableTransactorSession 

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

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

func (*DestroyableTransactorSession) Kill 

func (_Destroyable *DestroyableTransactorSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*DestroyableTransactorSession) TransferOwner 

func (_Destroyable *DestroyableTransactorSession) 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 Lockable 

type Lockable struct {
	LockableCaller     // Read-only binding to the contract
	LockableTransactor // Write-only binding to the contract
	LockableFilterer   // Log filterer for contract events
}

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

func DeployLockable 

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

DeployLockable deploys a new Ethereum contract, binding an instance of Lockable to it.

func NewLockable 

func NewLockable(address common.Address, backend bind.ContractBackend) (*Lockable, error)

NewLockable creates a new instance of Lockable, bound to a specific deployed contract.

type LockableCaller 

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

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

func NewLockableCaller 

func NewLockableCaller(address common.Address, caller bind.ContractCaller) (*LockableCaller, error)

NewLockableCaller creates a new read-only instance of Lockable, bound to a specific deployed contract.

func (*LockableCaller) IsLocked 

func (_Lockable *LockableCaller) 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 (*LockableCaller) Owner 

func (_Lockable *LockableCaller) 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 (*LockableCaller) ZEROADDRESS added in v0.2.0 

func (_Lockable *LockableCaller) 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 LockableCallerRaw 

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

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

func (*LockableCallerRaw) Call 

func (_Lockable *LockableCallerRaw) 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 LockableCallerSession 

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

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

func (*LockableCallerSession) IsLocked 

func (_Lockable *LockableCallerSession) IsLocked() (bool, error)

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

Solidity: function isLocked() constant returns(bool)

func (*LockableCallerSession) Owner 

func (_Lockable *LockableCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*LockableCallerSession) ZEROADDRESS added in v0.2.0 

func (_Lockable *LockableCallerSession) ZEROADDRESS() (common.Address, error)

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

Solidity: function ZERO_ADDRESS() constant returns(address)

type LockableDestroyable 

type LockableDestroyable struct {
	LockableDestroyableCaller     // Read-only binding to the contract
	LockableDestroyableTransactor // Write-only binding to the contract
	LockableDestroyableFilterer   // Log filterer for contract events
}

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

func DeployLockableDestroyable 

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

DeployLockableDestroyable deploys a new Ethereum contract, binding an instance of LockableDestroyable to it.

func NewLockableDestroyable 

func NewLockableDestroyable(address common.Address, backend bind.ContractBackend) (*LockableDestroyable, error)

NewLockableDestroyable creates a new instance of LockableDestroyable, bound to a specific deployed contract.

type LockableDestroyableCaller 

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

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

func NewLockableDestroyableCaller 

func NewLockableDestroyableCaller(address common.Address, caller bind.ContractCaller) (*LockableDestroyableCaller, error)

NewLockableDestroyableCaller creates a new read-only instance of LockableDestroyable, bound to a specific deployed contract.

func (*LockableDestroyableCaller) IsLocked 

func (_LockableDestroyable *LockableDestroyableCaller) 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 (*LockableDestroyableCaller) Owner 

func (_LockableDestroyable *LockableDestroyableCaller) 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 (*LockableDestroyableCaller) ZEROADDRESS added in v0.2.0 

func (_LockableDestroyable *LockableDestroyableCaller) 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 LockableDestroyableCallerRaw 

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

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

func (*LockableDestroyableCallerRaw) Call 

func (_LockableDestroyable *LockableDestroyableCallerRaw) 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 LockableDestroyableCallerSession 

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

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

func (*LockableDestroyableCallerSession) IsLocked 

func (_LockableDestroyable *LockableDestroyableCallerSession) IsLocked() (bool, error)

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

Solidity: function isLocked() constant returns(bool)

func (*LockableDestroyableCallerSession) Owner 

func (_LockableDestroyable *LockableDestroyableCallerSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*LockableDestroyableCallerSession) ZEROADDRESS added in v0.2.0 

func (_LockableDestroyable *LockableDestroyableCallerSession) ZEROADDRESS() (common.Address, error)

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

Solidity: function ZERO_ADDRESS() constant returns(address)

type LockableDestroyableFilterer 

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

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

func NewLockableDestroyableFilterer 

func NewLockableDestroyableFilterer(address common.Address, filterer bind.ContractFilterer) (*LockableDestroyableFilterer, error)

NewLockableDestroyableFilterer creates a new log filterer instance of LockableDestroyable, bound to a specific deployed contract.

func (*LockableDestroyableFilterer) FilterOwnerTransferred 

func (_LockableDestroyable *LockableDestroyableFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*LockableDestroyableOwnerTransferredIterator, error)

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

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

func (*LockableDestroyableFilterer) WatchOwnerTransferred 

func (_LockableDestroyable *LockableDestroyableFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *LockableDestroyableOwnerTransferred, 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 LockableDestroyableOwnerTransferred 

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

LockableDestroyableOwnerTransferred represents a OwnerTransferred event raised by the LockableDestroyable contract.

type LockableDestroyableOwnerTransferredIterator 

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

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

func (*LockableDestroyableOwnerTransferredIterator) Close 

func (it *LockableDestroyableOwnerTransferredIterator) Close() error

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

func (*LockableDestroyableOwnerTransferredIterator) Error 

func (it *LockableDestroyableOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*LockableDestroyableOwnerTransferredIterator) Next 

func (it *LockableDestroyableOwnerTransferredIterator) 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 LockableDestroyableRaw 

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

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

func (*LockableDestroyableRaw) Call 

func (_LockableDestroyable *LockableDestroyableRaw) 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 (*LockableDestroyableRaw) Transact 

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

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

func (*LockableDestroyableRaw) Transfer 

func (_LockableDestroyable *LockableDestroyableRaw) 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 LockableDestroyableSession 

type LockableDestroyableSession struct {
	Contract     *LockableDestroyable // 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
}

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

func (*LockableDestroyableSession) IsLocked 

func (_LockableDestroyable *LockableDestroyableSession) IsLocked() (bool, error)

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

Solidity: function isLocked() constant returns(bool)

func (*LockableDestroyableSession) Kill 

func (_LockableDestroyable *LockableDestroyableSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*LockableDestroyableSession) Owner 

func (_LockableDestroyable *LockableDestroyableSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*LockableDestroyableSession) SetLocked 

func (_LockableDestroyable *LockableDestroyableSession) SetLocked(locked bool) (*types.Transaction, error)

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

Solidity: function setLocked(locked bool) returns()

func (*LockableDestroyableSession) TransferOwner 

func (_LockableDestroyable *LockableDestroyableSession) 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 (*LockableDestroyableSession) ZEROADDRESS added in v0.2.0 

func (_LockableDestroyable *LockableDestroyableSession) ZEROADDRESS() (common.Address, error)

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

Solidity: function ZERO_ADDRESS() constant returns(address)

type LockableDestroyableTransactor 

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

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

func NewLockableDestroyableTransactor 

func NewLockableDestroyableTransactor(address common.Address, transactor bind.ContractTransactor) (*LockableDestroyableTransactor, error)

NewLockableDestroyableTransactor creates a new write-only instance of LockableDestroyable, bound to a specific deployed contract.

func (*LockableDestroyableTransactor) Kill 

func (_LockableDestroyable *LockableDestroyableTransactor) Kill(opts *bind.TransactOpts) (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*LockableDestroyableTransactor) SetLocked 

func (_LockableDestroyable *LockableDestroyableTransactor) 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 (*LockableDestroyableTransactor) TransferOwner 

func (_LockableDestroyable *LockableDestroyableTransactor) 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 LockableDestroyableTransactorRaw 

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

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

func (*LockableDestroyableTransactorRaw) Transact 

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

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

func (*LockableDestroyableTransactorRaw) Transfer 

func (_LockableDestroyable *LockableDestroyableTransactorRaw) 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 LockableDestroyableTransactorSession 

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

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

func (*LockableDestroyableTransactorSession) Kill 

func (_LockableDestroyable *LockableDestroyableTransactorSession) Kill() (*types.Transaction, error)

Kill is a paid mutator transaction binding the contract method 0x41c0e1b5.

Solidity: function kill() returns()

func (*LockableDestroyableTransactorSession) SetLocked 

func (_LockableDestroyable *LockableDestroyableTransactorSession) SetLocked(locked bool) (*types.Transaction, error)

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

Solidity: function setLocked(locked bool) returns()

func (*LockableDestroyableTransactorSession) TransferOwner 

func (_LockableDestroyable *LockableDestroyableTransactorSession) 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 LockableFilterer 

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

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

func NewLockableFilterer 

func NewLockableFilterer(address common.Address, filterer bind.ContractFilterer) (*LockableFilterer, error)

NewLockableFilterer creates a new log filterer instance of Lockable, bound to a specific deployed contract.

func (*LockableFilterer) FilterOwnerTransferred 

func (_Lockable *LockableFilterer) FilterOwnerTransferred(opts *bind.FilterOpts, oldOwner []common.Address, newOwner []common.Address) (*LockableOwnerTransferredIterator, error)

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

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

func (*LockableFilterer) WatchOwnerTransferred 

func (_Lockable *LockableFilterer) WatchOwnerTransferred(opts *bind.WatchOpts, sink chan<- *LockableOwnerTransferred, 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 LockableOwnerTransferred 

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

LockableOwnerTransferred represents a OwnerTransferred event raised by the Lockable contract.

type LockableOwnerTransferredIterator 

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

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

func (*LockableOwnerTransferredIterator) Close 

func (it *LockableOwnerTransferredIterator) Close() error

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

func (*LockableOwnerTransferredIterator) Error 

func (it *LockableOwnerTransferredIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*LockableOwnerTransferredIterator) Next 

func (it *LockableOwnerTransferredIterator) 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 LockableRaw 

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

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

func (*LockableRaw) Call 

func (_Lockable *LockableRaw) 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 (*LockableRaw) Transact 

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

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

func (*LockableRaw) Transfer 

func (_Lockable *LockableRaw) 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 LockableSession 

type LockableSession struct {
	Contract     *Lockable         // 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
}

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

func (*LockableSession) IsLocked 

func (_Lockable *LockableSession) IsLocked() (bool, error)

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

Solidity: function isLocked() constant returns(bool)

func (*LockableSession) Owner 

func (_Lockable *LockableSession) Owner() (common.Address, error)

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

Solidity: function owner() constant returns(address)

func (*LockableSession) SetLocked 

func (_Lockable *LockableSession) SetLocked(locked bool) (*types.Transaction, error)

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

Solidity: function setLocked(locked bool) returns()

func (*LockableSession) TransferOwner 

func (_Lockable *LockableSession) 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 (*LockableSession) ZEROADDRESS added in v0.2.0 

func (_Lockable *LockableSession) ZEROADDRESS() (common.Address, error)

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

Solidity: function ZERO_ADDRESS() constant returns(address)

type LockableTransactor 

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

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

func NewLockableTransactor 

func NewLockableTransactor(address common.Address, transactor bind.ContractTransactor) (*LockableTransactor, error)

NewLockableTransactor creates a new write-only instance of Lockable, bound to a specific deployed contract.

func (*LockableTransactor) SetLocked 

func (_Lockable *LockableTransactor) 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 (*LockableTransactor) TransferOwner 

func (_Lockable *LockableTransactor) 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 LockableTransactorRaw 

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

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

func (*LockableTransactorRaw) Transact 

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

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

func (*LockableTransactorRaw) Transfer 

func (_Lockable *LockableTransactorRaw) 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 LockableTransactorSession 

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

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

func (*LockableTransactorSession) SetLocked 

func (_Lockable *LockableTransactorSession) SetLocked(locked bool) (*types.Transaction, error)

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

Solidity: function setLocked(locked bool) returns()

func (*LockableTransactorSession) TransferOwner 

func (_Lockable *LockableTransactorSession) 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.