Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

registry

package

Go to main page

Versions in this module

v3

v3.5.7

Jun 17, 2022

Changes in this version

+ var ContractMetaData = &bind.MetaData

v3.5.6

Jun 17, 2022

v3.5.5

Jun 17, 2022

Changes in this version

+ const ContractABI

+ type Contract struct

+ func NewContract(address common.Address, backend bind.ContractBackend) (*Contract, error)

+ type ContractCaller struct

+ func NewContractCaller(address common.Address, caller bind.ContractCaller) (*ContractCaller, error)

+ func (_Contract *ContractCaller) Owner(opts *bind.CallOpts, node [32]byte) (common.Address, error)

+ func (_Contract *ContractCaller) Resolver(opts *bind.CallOpts, node [32]byte) (common.Address, error)

+ func (_Contract *ContractCaller) Ttl(opts *bind.CallOpts, node [32]byte) (uint64, error)

+ type ContractCallerRaw struct

+ Contract *ContractCaller

+ func (_Contract *ContractCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ContractCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ContractCaller

+ func (_Contract *ContractCallerSession) Owner(node [32]byte) (common.Address, error)

+ func (_Contract *ContractCallerSession) Resolver(node [32]byte) (common.Address, error)

+ func (_Contract *ContractCallerSession) Ttl(node [32]byte) (uint64, error)

+ type ContractFilterer struct

+ func NewContractFilterer(address common.Address, filterer bind.ContractFilterer) (*ContractFilterer, error)

+ func (_Contract *ContractFilterer) FilterNewOwner(opts *bind.FilterOpts, node [][32]byte, label [][32]byte) (*ContractNewOwnerIterator, error)

+ func (_Contract *ContractFilterer) FilterNewResolver(opts *bind.FilterOpts, node [][32]byte) (*ContractNewResolverIterator, error)

+ func (_Contract *ContractFilterer) FilterNewTTL(opts *bind.FilterOpts, node [][32]byte) (*ContractNewTTLIterator, error)

+ func (_Contract *ContractFilterer) FilterTransfer(opts *bind.FilterOpts, node [][32]byte) (*ContractTransferIterator, error)

+ func (_Contract *ContractFilterer) ParseNewOwner(log types.Log) (*ContractNewOwner, error)

+ func (_Contract *ContractFilterer) ParseNewResolver(log types.Log) (*ContractNewResolver, error)

+ func (_Contract *ContractFilterer) ParseNewTTL(log types.Log) (*ContractNewTTL, error)

+ func (_Contract *ContractFilterer) ParseTransfer(log types.Log) (*ContractTransfer, error)

+ func (_Contract *ContractFilterer) WatchNewOwner(opts *bind.WatchOpts, sink chan<- *ContractNewOwner, node [][32]byte, ...) (event.Subscription, error)

+ func (_Contract *ContractFilterer) WatchNewResolver(opts *bind.WatchOpts, sink chan<- *ContractNewResolver, node [][32]byte) (event.Subscription, error)

+ func (_Contract *ContractFilterer) WatchNewTTL(opts *bind.WatchOpts, sink chan<- *ContractNewTTL, node [][32]byte) (event.Subscription, error)

+ func (_Contract *ContractFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ContractTransfer, node [][32]byte) (event.Subscription, error)

+ type ContractNewOwner struct

+ Label [32]byte

+ Node [32]byte

+ Owner common.Address

+ Raw types.Log

+ type ContractNewOwnerIterator struct

+ Event *ContractNewOwner

+ func (it *ContractNewOwnerIterator) Close() error

+ func (it *ContractNewOwnerIterator) Error() error

+ func (it *ContractNewOwnerIterator) Next() bool

+ type ContractNewResolver struct

+ Node [32]byte

+ Raw types.Log

+ Resolver common.Address

+ type ContractNewResolverIterator struct

+ Event *ContractNewResolver

+ func (it *ContractNewResolverIterator) Close() error

+ func (it *ContractNewResolverIterator) Error() error

+ func (it *ContractNewResolverIterator) Next() bool

+ type ContractNewTTL struct

+ Node [32]byte

+ Raw types.Log

+ Ttl uint64

+ type ContractNewTTLIterator struct

+ Event *ContractNewTTL

+ func (it *ContractNewTTLIterator) Close() error

+ func (it *ContractNewTTLIterator) Error() error

+ func (it *ContractNewTTLIterator) Next() bool

+ type ContractRaw struct

+ Contract *Contract

+ func (_Contract *ContractRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_Contract *ContractRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Contract *ContractRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ContractSession struct

+ CallOpts bind.CallOpts

+ Contract *Contract

+ TransactOpts bind.TransactOpts

+ func (_Contract *ContractSession) Owner(node [32]byte) (common.Address, error)

+ func (_Contract *ContractSession) Resolver(node [32]byte) (common.Address, error)

+ func (_Contract *ContractSession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error)

+ func (_Contract *ContractSession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error)

+ func (_Contract *ContractSession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error)

+ func (_Contract *ContractSession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error)

+ func (_Contract *ContractSession) Ttl(node [32]byte) (uint64, error)

+ type ContractTransactor struct

+ func NewContractTransactor(address common.Address, transactor bind.ContractTransactor) (*ContractTransactor, error)

+ func (_Contract *ContractTransactor) SetOwner(opts *bind.TransactOpts, node [32]byte, owner common.Address) (*types.Transaction, error)

+ func (_Contract *ContractTransactor) SetResolver(opts *bind.TransactOpts, node [32]byte, resolver common.Address) (*types.Transaction, error)

+ func (_Contract *ContractTransactor) SetSubnodeOwner(opts *bind.TransactOpts, node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error)

+ func (_Contract *ContractTransactor) SetTTL(opts *bind.TransactOpts, node [32]byte, ttl uint64) (*types.Transaction, error)

+ type ContractTransactorRaw struct

+ Contract *ContractTransactor

+ func (_Contract *ContractTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Contract *ContractTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ContractTransactorSession struct

+ Contract *ContractTransactor

+ TransactOpts bind.TransactOpts

+ func (_Contract *ContractTransactorSession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error)

+ func (_Contract *ContractTransactorSession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error)

+ func (_Contract *ContractTransactorSession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error)

+ func (_Contract *ContractTransactorSession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error)

+ type ContractTransfer struct

+ Node [32]byte

+ Owner common.Address

+ Raw types.Log

+ type ContractTransferIterator struct

+ Event *ContractTransfer

+ func (it *ContractTransferIterator) Close() error

+ func (it *ContractTransferIterator) Error() error

+ func (it *ContractTransferIterator) Next() bool