contracts

package
v0.0.0-...-783b753 Latest Latest
Warning

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

 Go to latest Published: Mar 6, 2019 License: BSD-2-Clause Imports: 8 Imported by: 4

Documentation

Index

Constants

View Source 
const DNSRegistrarABI = "" /* 895-byte string literal not displayed */

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

View Source 
const DNSRegistrarBin = `0x`

DNSRegistrarBin is the compiled bytecode used for deploying new contracts.

View Source 
const DNSSECABI = "" /* 1605-byte string literal not displayed */

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

View Source 
const DNSSECBin = `0x`

DNSSECBin is the compiled bytecode used for deploying new contracts.

View Source 
const ENSABI = "" /* 2442-byte string literal not displayed */

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

View Source 
const ENSBin = `0x`

ENSBin is the compiled bytecode used for deploying new contracts.

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

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

View Source 
const ResolverBin = `0x`

ResolverBin is the compiled bytecode used for deploying new contracts.

View Source 
const RootABI = "" /* 1190-byte string literal not displayed */

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

View Source 
const RootBin = `0x`

RootBin is the compiled bytecode used for deploying new contracts.

Variables

This section is empty.

Functions

This section is empty.

Types

type DNSRegistrar 

type DNSRegistrar struct {
	DNSRegistrarCaller     // Read-only binding to the contract
	DNSRegistrarTransactor // Write-only binding to the contract
	DNSRegistrarFilterer   // Log filterer for contract events
}

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

func DeployDNSRegistrar 

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

DeployDNSRegistrar deploys a new Ethereum contract, binding an instance of DNSRegistrar to it.

func NewDNSRegistrar 

func NewDNSRegistrar(address common.Address, backend bind.ContractBackend) (*DNSRegistrar, error)

NewDNSRegistrar creates a new instance of DNSRegistrar, bound to a specific deployed contract.

type DNSRegistrarCaller 

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

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

func NewDNSRegistrarCaller 

func NewDNSRegistrarCaller(address common.Address, caller bind.ContractCaller) (*DNSRegistrarCaller, error)

NewDNSRegistrarCaller creates a new read-only instance of DNSRegistrar, bound to a specific deployed contract.

func (*DNSRegistrarCaller) Oracle 

func (_DNSRegistrar *DNSRegistrarCaller) Oracle(opts *bind.CallOpts) (common.Address, error)

Oracle is a free data retrieval call binding the contract method 0x7dc0d1d0.

Solidity: function oracle() constant returns(address)

func (*DNSRegistrarCaller) SupportsInterface 

func (_DNSRegistrar *DNSRegistrarCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error)

SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.

Solidity: function supportsInterface(bytes4 interfaceID) constant returns(bool)

type DNSRegistrarCallerRaw 

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

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

func (*DNSRegistrarCallerRaw) Call 

func (_DNSRegistrar *DNSRegistrarCallerRaw) 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 DNSRegistrarCallerSession 

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

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

func (*DNSRegistrarCallerSession) Oracle 

func (_DNSRegistrar *DNSRegistrarCallerSession) Oracle() (common.Address, error)

Oracle is a free data retrieval call binding the contract method 0x7dc0d1d0.

Solidity: function oracle() constant returns(address)

func (*DNSRegistrarCallerSession) SupportsInterface 

func (_DNSRegistrar *DNSRegistrarCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error)

SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.

Solidity: function supportsInterface(bytes4 interfaceID) constant returns(bool)

type DNSRegistrarFilterer 

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

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

func NewDNSRegistrarFilterer 

func NewDNSRegistrarFilterer(address common.Address, filterer bind.ContractFilterer) (*DNSRegistrarFilterer, error)

NewDNSRegistrarFilterer creates a new log filterer instance of DNSRegistrar, bound to a specific deployed contract.

type DNSRegistrarRaw 

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

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

func (*DNSRegistrarRaw) Call 

func (_DNSRegistrar *DNSRegistrarRaw) 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 (*DNSRegistrarRaw) Transact 

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

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

func (*DNSRegistrarRaw) Transfer 

func (_DNSRegistrar *DNSRegistrarRaw) 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 DNSRegistrarSession 

type DNSRegistrarSession struct {
	Contract     *DNSRegistrar     // 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
}

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

func (*DNSRegistrarSession) Claim 

func (_DNSRegistrar *DNSRegistrarSession) Claim(name []byte, proof []byte) (*types.Transaction, error)

Claim is a paid mutator transaction binding the contract method 0xbe27b22c.

Solidity: function claim(bytes name, bytes proof) returns()

func (*DNSRegistrarSession) Oracle 

func (_DNSRegistrar *DNSRegistrarSession) Oracle() (common.Address, error)

Oracle is a free data retrieval call binding the contract method 0x7dc0d1d0.

Solidity: function oracle() constant returns(address)

func (*DNSRegistrarSession) ProveAndClaim 

func (_DNSRegistrar *DNSRegistrarSession) ProveAndClaim(name []byte, input []byte, proof []byte) (*types.Transaction, error)

ProveAndClaim is a paid mutator transaction binding the contract method 0xd94585bd.

Solidity: function proveAndClaim(bytes name, bytes input, bytes proof) returns()

func (*DNSRegistrarSession) SupportsInterface 

func (_DNSRegistrar *DNSRegistrarSession) SupportsInterface(interfaceID [4]byte) (bool, error)

SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.

Solidity: function supportsInterface(bytes4 interfaceID) constant returns(bool)

type DNSRegistrarTransactor 

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

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

func NewDNSRegistrarTransactor 

func NewDNSRegistrarTransactor(address common.Address, transactor bind.ContractTransactor) (*DNSRegistrarTransactor, error)

NewDNSRegistrarTransactor creates a new write-only instance of DNSRegistrar, bound to a specific deployed contract.

func (*DNSRegistrarTransactor) Claim 

func (_DNSRegistrar *DNSRegistrarTransactor) Claim(opts *bind.TransactOpts, name []byte, proof []byte) (*types.Transaction, error)

Claim is a paid mutator transaction binding the contract method 0xbe27b22c.

Solidity: function claim(bytes name, bytes proof) returns()

func (*DNSRegistrarTransactor) ProveAndClaim 

func (_DNSRegistrar *DNSRegistrarTransactor) ProveAndClaim(opts *bind.TransactOpts, name []byte, input []byte, proof []byte) (*types.Transaction, error)

ProveAndClaim is a paid mutator transaction binding the contract method 0xd94585bd.

Solidity: function proveAndClaim(bytes name, bytes input, bytes proof) returns()

type DNSRegistrarTransactorRaw 

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

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

func (*DNSRegistrarTransactorRaw) Transact 

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

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

func (*DNSRegistrarTransactorRaw) Transfer 

func (_DNSRegistrar *DNSRegistrarTransactorRaw) 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 DNSRegistrarTransactorSession 

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

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

func (*DNSRegistrarTransactorSession) Claim 

func (_DNSRegistrar *DNSRegistrarTransactorSession) Claim(name []byte, proof []byte) (*types.Transaction, error)

Claim is a paid mutator transaction binding the contract method 0xbe27b22c.

Solidity: function claim(bytes name, bytes proof) returns()

func (*DNSRegistrarTransactorSession) ProveAndClaim 

func (_DNSRegistrar *DNSRegistrarTransactorSession) ProveAndClaim(name []byte, input []byte, proof []byte) (*types.Transaction, error)

ProveAndClaim is a paid mutator transaction binding the contract method 0xd94585bd.

Solidity: function proveAndClaim(bytes name, bytes input, bytes proof) returns()

type DNSSEC 

type DNSSEC struct {
	DNSSECCaller     // Read-only binding to the contract
	DNSSECTransactor // Write-only binding to the contract
	DNSSECFilterer   // Log filterer for contract events
}

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

func DeployDNSSEC 

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

DeployDNSSEC deploys a new Ethereum contract, binding an instance of DNSSEC to it.

func NewDNSSEC 

func NewDNSSEC(address common.Address, backend bind.ContractBackend) (*DNSSEC, error)

NewDNSSEC creates a new instance of DNSSEC, bound to a specific deployed contract.

type DNSSECCaller 

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

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

func NewDNSSECCaller 

func NewDNSSECCaller(address common.Address, caller bind.ContractCaller) (*DNSSECCaller, error)

NewDNSSECCaller creates a new read-only instance of DNSSEC, bound to a specific deployed contract.

func (*DNSSECCaller) Anchors 

func (_DNSSEC *DNSSECCaller) Anchors(opts *bind.CallOpts) ([]byte, error)

Anchors is a free data retrieval call binding the contract method 0x98d35f20.

Solidity: function anchors() constant returns(bytes)

func (*DNSSECCaller) Rrdata 

func (_DNSSEC *DNSSECCaller) Rrdata(opts *bind.CallOpts, dnstype uint16, name []byte) (struct {
	Inception uint32
	Inserted  uint64
	Hash      [20]byte
}, error)

Rrdata is a free data retrieval call binding the contract method 0x087991bc.

Solidity: function rrdata(uint16 dnstype, bytes name) constant returns(uint32 inception, uint64 inserted, bytes20 hash)

type DNSSECCallerRaw 

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

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

func (*DNSSECCallerRaw) Call 

func (_DNSSEC *DNSSECCallerRaw) 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 DNSSECCallerSession 

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

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

func (*DNSSECCallerSession) Anchors 

func (_DNSSEC *DNSSECCallerSession) Anchors() ([]byte, error)

Anchors is a free data retrieval call binding the contract method 0x98d35f20.

Solidity: function anchors() constant returns(bytes)

func (*DNSSECCallerSession) Rrdata 

func (_DNSSEC *DNSSECCallerSession) Rrdata(dnstype uint16, name []byte) (struct {
	Inception uint32
	Inserted  uint64
	Hash      [20]byte
}, error)

Rrdata is a free data retrieval call binding the contract method 0x087991bc.

Solidity: function rrdata(uint16 dnstype, bytes name) constant returns(uint32 inception, uint64 inserted, bytes20 hash)

type DNSSECFilterer 

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

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

func NewDNSSECFilterer 

func NewDNSSECFilterer(address common.Address, filterer bind.ContractFilterer) (*DNSSECFilterer, error)

NewDNSSECFilterer creates a new log filterer instance of DNSSEC, bound to a specific deployed contract.

func (*DNSSECFilterer) FilterRRSetUpdated 

func (_DNSSEC *DNSSECFilterer) FilterRRSetUpdated(opts *bind.FilterOpts) (*DNSSECRRSetUpdatedIterator, error)

FilterRRSetUpdated is a free log retrieval operation binding the contract event 0x55ced933cdd5a34dd03eb5d4bef19ec6ebb251dcd7a988eee0c1b9a13baaa88b.

Solidity: event RRSetUpdated(bytes name, bytes rrset)

func (*DNSSECFilterer) WatchRRSetUpdated 

func (_DNSSEC *DNSSECFilterer) WatchRRSetUpdated(opts *bind.WatchOpts, sink chan<- *DNSSECRRSetUpdated) (event.Subscription, error)

WatchRRSetUpdated is a free log subscription operation binding the contract event 0x55ced933cdd5a34dd03eb5d4bef19ec6ebb251dcd7a988eee0c1b9a13baaa88b.

Solidity: event RRSetUpdated(bytes name, bytes rrset)

type DNSSECRRSetUpdated 

type DNSSECRRSetUpdated struct {
	Name  []byte
	Rrset []byte
	Raw   types.Log // Blockchain specific contextual infos
}

DNSSECRRSetUpdated represents a RRSetUpdated event raised by the DNSSEC contract.

type DNSSECRRSetUpdatedIterator 

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

DNSSECRRSetUpdatedIterator is returned from FilterRRSetUpdated and is used to iterate over the raw logs and unpacked data for RRSetUpdated events raised by the DNSSEC contract.

func (*DNSSECRRSetUpdatedIterator) Close 

func (it *DNSSECRRSetUpdatedIterator) Close() error

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

func (*DNSSECRRSetUpdatedIterator) Error 

func (it *DNSSECRRSetUpdatedIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*DNSSECRRSetUpdatedIterator) Next 

func (it *DNSSECRRSetUpdatedIterator) 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 DNSSECRaw 

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

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

func (*DNSSECRaw) Call 

func (_DNSSEC *DNSSECRaw) 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 (*DNSSECRaw) Transact 

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

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

func (*DNSSECRaw) Transfer 

func (_DNSSEC *DNSSECRaw) 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 DNSSECSession 

type DNSSECSession struct {
	Contract     *DNSSEC           // 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
}

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

func (*DNSSECSession) Anchors 

func (_DNSSEC *DNSSECSession) Anchors() ([]byte, error)

Anchors is a free data retrieval call binding the contract method 0x98d35f20.

Solidity: function anchors() constant returns(bytes)

func (*DNSSECSession) DeleteRRSet 

func (_DNSSEC *DNSSECSession) DeleteRRSet(deletetype uint16, deletename []byte, nsec []byte, sig []byte, proof []byte) (*types.Transaction, error)

DeleteRRSet is a paid mutator transaction binding the contract method 0xe60b202f.

Solidity: function deleteRRSet(uint16 deletetype, bytes deletename, bytes nsec, bytes sig, bytes proof) returns()

func (*DNSSECSession) Rrdata 

func (_DNSSEC *DNSSECSession) Rrdata(dnstype uint16, name []byte) (struct {
	Inception uint32
	Inserted  uint64
	Hash      [20]byte
}, error)

Rrdata is a free data retrieval call binding the contract method 0x087991bc.

Solidity: function rrdata(uint16 dnstype, bytes name) constant returns(uint32 inception, uint64 inserted, bytes20 hash)

func (*DNSSECSession) SubmitRRSet 

func (_DNSSEC *DNSSECSession) SubmitRRSet(input []byte, sig []byte, proof []byte) (*types.Transaction, error)

SubmitRRSet is a paid mutator transaction binding the contract method 0x4d46d581.

Solidity: function submitRRSet(bytes input, bytes sig, bytes proof) returns()

func (*DNSSECSession) SubmitRRSets 

func (_DNSSEC *DNSSECSession) SubmitRRSets(data []byte, _proof []byte) (*types.Transaction, error)

SubmitRRSets is a paid mutator transaction binding the contract method 0x76a14d1d.

Solidity: function submitRRSets(bytes data, bytes _proof) returns(bytes)

type DNSSECTransactor 

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

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

func NewDNSSECTransactor 

func NewDNSSECTransactor(address common.Address, transactor bind.ContractTransactor) (*DNSSECTransactor, error)

NewDNSSECTransactor creates a new write-only instance of DNSSEC, bound to a specific deployed contract.

func (*DNSSECTransactor) DeleteRRSet 

func (_DNSSEC *DNSSECTransactor) DeleteRRSet(opts *bind.TransactOpts, deletetype uint16, deletename []byte, nsec []byte, sig []byte, proof []byte) (*types.Transaction, error)

DeleteRRSet is a paid mutator transaction binding the contract method 0xe60b202f.

Solidity: function deleteRRSet(uint16 deletetype, bytes deletename, bytes nsec, bytes sig, bytes proof) returns()

func (*DNSSECTransactor) SubmitRRSet 

func (_DNSSEC *DNSSECTransactor) SubmitRRSet(opts *bind.TransactOpts, input []byte, sig []byte, proof []byte) (*types.Transaction, error)

SubmitRRSet is a paid mutator transaction binding the contract method 0x4d46d581.

Solidity: function submitRRSet(bytes input, bytes sig, bytes proof) returns()

func (*DNSSECTransactor) SubmitRRSets 

func (_DNSSEC *DNSSECTransactor) SubmitRRSets(opts *bind.TransactOpts, data []byte, _proof []byte) (*types.Transaction, error)

SubmitRRSets is a paid mutator transaction binding the contract method 0x76a14d1d.

Solidity: function submitRRSets(bytes data, bytes _proof) returns(bytes)

type DNSSECTransactorRaw 

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

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

func (*DNSSECTransactorRaw) Transact 

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

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

func (*DNSSECTransactorRaw) Transfer 

func (_DNSSEC *DNSSECTransactorRaw) 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 DNSSECTransactorSession 

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

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

func (*DNSSECTransactorSession) DeleteRRSet 

func (_DNSSEC *DNSSECTransactorSession) DeleteRRSet(deletetype uint16, deletename []byte, nsec []byte, sig []byte, proof []byte) (*types.Transaction, error)

DeleteRRSet is a paid mutator transaction binding the contract method 0xe60b202f.

Solidity: function deleteRRSet(uint16 deletetype, bytes deletename, bytes nsec, bytes sig, bytes proof) returns()

func (*DNSSECTransactorSession) SubmitRRSet 

func (_DNSSEC *DNSSECTransactorSession) SubmitRRSet(input []byte, sig []byte, proof []byte) (*types.Transaction, error)

SubmitRRSet is a paid mutator transaction binding the contract method 0x4d46d581.

Solidity: function submitRRSet(bytes input, bytes sig, bytes proof) returns()

func (*DNSSECTransactorSession) SubmitRRSets 

func (_DNSSEC *DNSSECTransactorSession) SubmitRRSets(data []byte, _proof []byte) (*types.Transaction, error)

SubmitRRSets is a paid mutator transaction binding the contract method 0x76a14d1d.

Solidity: function submitRRSets(bytes data, bytes _proof) returns(bytes)

type ENS 

type ENS struct {
	ENSCaller     // Read-only binding to the contract
	ENSTransactor // Write-only binding to the contract
	ENSFilterer   // Log filterer for contract events
}

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

func DeployENS 

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

DeployENS deploys a new Ethereum contract, binding an instance of ENS to it.

func NewENS 

func NewENS(address common.Address, backend bind.ContractBackend) (*ENS, error)

NewENS creates a new instance of ENS, bound to a specific deployed contract.

type ENSCaller 

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

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

func NewENSCaller 

func NewENSCaller(address common.Address, caller bind.ContractCaller) (*ENSCaller, error)

NewENSCaller creates a new read-only instance of ENS, bound to a specific deployed contract.

func (*ENSCaller) Owner 

func (_ENS *ENSCaller) Owner(opts *bind.CallOpts, node [32]byte) (common.Address, error)

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

Solidity: function owner(bytes32 node) constant returns(address)

func (*ENSCaller) Resolver 

func (_ENS *ENSCaller) Resolver(opts *bind.CallOpts, node [32]byte) (common.Address, error)

Resolver is a free data retrieval call binding the contract method 0x0178b8bf.

Solidity: function resolver(bytes32 node) constant returns(address)

func (*ENSCaller) Ttl 

func (_ENS *ENSCaller) Ttl(opts *bind.CallOpts, node [32]byte) (uint64, error)

Ttl is a free data retrieval call binding the contract method 0x16a25cbd.

Solidity: function ttl(bytes32 node) constant returns(uint64)

type ENSCallerRaw 

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

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

func (*ENSCallerRaw) Call 

func (_ENS *ENSCallerRaw) 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 ENSCallerSession 

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

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

func (*ENSCallerSession) Owner 

func (_ENS *ENSCallerSession) Owner(node [32]byte) (common.Address, error)

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

Solidity: function owner(bytes32 node) constant returns(address)

func (*ENSCallerSession) Resolver 

func (_ENS *ENSCallerSession) Resolver(node [32]byte) (common.Address, error)

Resolver is a free data retrieval call binding the contract method 0x0178b8bf.

Solidity: function resolver(bytes32 node) constant returns(address)

func (*ENSCallerSession) Ttl 

func (_ENS *ENSCallerSession) Ttl(node [32]byte) (uint64, error)

Ttl is a free data retrieval call binding the contract method 0x16a25cbd.

Solidity: function ttl(bytes32 node) constant returns(uint64)

type ENSFilterer 

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

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

func NewENSFilterer 

func NewENSFilterer(address common.Address, filterer bind.ContractFilterer) (*ENSFilterer, error)

NewENSFilterer creates a new log filterer instance of ENS, bound to a specific deployed contract.

func (*ENSFilterer) FilterNewOwner 

func (_ENS *ENSFilterer) FilterNewOwner(opts *bind.FilterOpts, node [][32]byte, label [][32]byte) (*ENSNewOwnerIterator, error)

FilterNewOwner is a free log retrieval operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82.

Solidity: event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner)

func (*ENSFilterer) FilterNewResolver 

func (_ENS *ENSFilterer) FilterNewResolver(opts *bind.FilterOpts, node [][32]byte) (*ENSNewResolverIterator, error)

FilterNewResolver is a free log retrieval operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0.

Solidity: event NewResolver(bytes32 indexed node, address resolver)

func (*ENSFilterer) FilterNewTTL 

func (_ENS *ENSFilterer) FilterNewTTL(opts *bind.FilterOpts, node [][32]byte) (*ENSNewTTLIterator, error)

FilterNewTTL is a free log retrieval operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68.

Solidity: event NewTTL(bytes32 indexed node, uint64 ttl)

func (*ENSFilterer) FilterTransfer 

func (_ENS *ENSFilterer) FilterTransfer(opts *bind.FilterOpts, node [][32]byte) (*ENSTransferIterator, error)

FilterTransfer is a free log retrieval operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266.

Solidity: event Transfer(bytes32 indexed node, address owner)

func (*ENSFilterer) WatchNewOwner 

func (_ENS *ENSFilterer) WatchNewOwner(opts *bind.WatchOpts, sink chan<- *ENSNewOwner, node [][32]byte, label [][32]byte) (event.Subscription, error)

WatchNewOwner is a free log subscription operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82.

Solidity: event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner)

func (*ENSFilterer) WatchNewResolver 

func (_ENS *ENSFilterer) WatchNewResolver(opts *bind.WatchOpts, sink chan<- *ENSNewResolver, node [][32]byte) (event.Subscription, error)

WatchNewResolver is a free log subscription operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0.

Solidity: event NewResolver(bytes32 indexed node, address resolver)

func (*ENSFilterer) WatchNewTTL 

func (_ENS *ENSFilterer) WatchNewTTL(opts *bind.WatchOpts, sink chan<- *ENSNewTTL, node [][32]byte) (event.Subscription, error)

WatchNewTTL is a free log subscription operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68.

Solidity: event NewTTL(bytes32 indexed node, uint64 ttl)

func (*ENSFilterer) WatchTransfer 

func (_ENS *ENSFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ENSTransfer, node [][32]byte) (event.Subscription, error)

WatchTransfer is a free log subscription operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266.

Solidity: event Transfer(bytes32 indexed node, address owner)

type ENSNewOwner 

type ENSNewOwner struct {
	Node  [32]byte
	Label [32]byte
	Owner common.Address
	Raw   types.Log // Blockchain specific contextual infos
}

ENSNewOwner represents a NewOwner event raised by the ENS contract.

type ENSNewOwnerIterator 

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

ENSNewOwnerIterator is returned from FilterNewOwner and is used to iterate over the raw logs and unpacked data for NewOwner events raised by the ENS contract.

func (*ENSNewOwnerIterator) Close 

func (it *ENSNewOwnerIterator) Close() error

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

func (*ENSNewOwnerIterator) Error 

func (it *ENSNewOwnerIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ENSNewOwnerIterator) Next 

func (it *ENSNewOwnerIterator) 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 ENSNewResolver 

type ENSNewResolver struct {
	Node     [32]byte
	Resolver common.Address
	Raw      types.Log // Blockchain specific contextual infos
}

ENSNewResolver represents a NewResolver event raised by the ENS contract.

type ENSNewResolverIterator 

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

ENSNewResolverIterator is returned from FilterNewResolver and is used to iterate over the raw logs and unpacked data for NewResolver events raised by the ENS contract.

func (*ENSNewResolverIterator) Close 

func (it *ENSNewResolverIterator) Close() error

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

func (*ENSNewResolverIterator) Error 

func (it *ENSNewResolverIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ENSNewResolverIterator) Next 

func (it *ENSNewResolverIterator) 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 ENSNewTTL 

type ENSNewTTL struct {
	Node [32]byte
	Ttl  uint64
	Raw  types.Log // Blockchain specific contextual infos
}

ENSNewTTL represents a NewTTL event raised by the ENS contract.

type ENSNewTTLIterator 

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

ENSNewTTLIterator is returned from FilterNewTTL and is used to iterate over the raw logs and unpacked data for NewTTL events raised by the ENS contract.

func (*ENSNewTTLIterator) Close 

func (it *ENSNewTTLIterator) Close() error

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

func (*ENSNewTTLIterator) Error 

func (it *ENSNewTTLIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ENSNewTTLIterator) Next 

func (it *ENSNewTTLIterator) 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 ENSRaw 

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

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

func (*ENSRaw) Call 

func (_ENS *ENSRaw) 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 (*ENSRaw) Transact 

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

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

func (*ENSRaw) Transfer 

func (_ENS *ENSRaw) 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 ENSSession 

type ENSSession struct {
	Contract     *ENS              // 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
}

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

func (*ENSSession) Owner 

func (_ENS *ENSSession) Owner(node [32]byte) (common.Address, error)

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

Solidity: function owner(bytes32 node) constant returns(address)

func (*ENSSession) Resolver 

func (_ENS *ENSSession) Resolver(node [32]byte) (common.Address, error)

Resolver is a free data retrieval call binding the contract method 0x0178b8bf.

Solidity: function resolver(bytes32 node) constant returns(address)

func (*ENSSession) SetOwner 

func (_ENS *ENSSession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error)

SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.

Solidity: function setOwner(bytes32 node, address owner) returns()

func (*ENSSession) SetResolver 

func (_ENS *ENSSession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error)

SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.

Solidity: function setResolver(bytes32 node, address resolver) returns()

func (*ENSSession) SetSubnodeOwner 

func (_ENS *ENSSession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error)

SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923.

Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns()

func (*ENSSession) SetTTL 

func (_ENS *ENSSession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error)

SetTTL is a paid mutator transaction binding the contract method 0x14ab9038.

Solidity: function setTTL(bytes32 node, uint64 ttl) returns()

func (*ENSSession) Ttl 

func (_ENS *ENSSession) Ttl(node [32]byte) (uint64, error)

Ttl is a free data retrieval call binding the contract method 0x16a25cbd.

Solidity: function ttl(bytes32 node) constant returns(uint64)

type ENSTransactor 

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

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

func NewENSTransactor 

func NewENSTransactor(address common.Address, transactor bind.ContractTransactor) (*ENSTransactor, error)

NewENSTransactor creates a new write-only instance of ENS, bound to a specific deployed contract.

func (*ENSTransactor) SetOwner 

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

SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.

Solidity: function setOwner(bytes32 node, address owner) returns()

func (*ENSTransactor) SetResolver 

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

SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.

Solidity: function setResolver(bytes32 node, address resolver) returns()

func (*ENSTransactor) SetSubnodeOwner 

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

SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923.

Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns()

func (*ENSTransactor) SetTTL 

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

SetTTL is a paid mutator transaction binding the contract method 0x14ab9038.

Solidity: function setTTL(bytes32 node, uint64 ttl) returns()

type ENSTransactorRaw 

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

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

func (*ENSTransactorRaw) Transact 

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

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

func (*ENSTransactorRaw) Transfer 

func (_ENS *ENSTransactorRaw) 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 ENSTransactorSession 

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

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

func (*ENSTransactorSession) SetOwner 

func (_ENS *ENSTransactorSession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error)

SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.

Solidity: function setOwner(bytes32 node, address owner) returns()

func (*ENSTransactorSession) SetResolver 

func (_ENS *ENSTransactorSession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error)

SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.

Solidity: function setResolver(bytes32 node, address resolver) returns()

func (*ENSTransactorSession) SetSubnodeOwner 

func (_ENS *ENSTransactorSession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error)

SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923.

Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns()

func (*ENSTransactorSession) SetTTL 

func (_ENS *ENSTransactorSession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error)

SetTTL is a paid mutator transaction binding the contract method 0x14ab9038.

Solidity: function setTTL(bytes32 node, uint64 ttl) returns()

type ENSTransfer 

type ENSTransfer struct {
	Node  [32]byte
	Owner common.Address
	Raw   types.Log // Blockchain specific contextual infos
}

ENSTransfer represents a Transfer event raised by the ENS contract.

type ENSTransferIterator 

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

ENSTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ENS contract.

func (*ENSTransferIterator) Close 

func (it *ENSTransferIterator) Close() error

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

func (*ENSTransferIterator) Error 

func (it *ENSTransferIterator) Error() error

Error returns any retrieval or parsing error occurred during filtering.

func (*ENSTransferIterator) Next 

func (it *ENSTransferIterator) 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 Resolver 

type Resolver struct {
	ResolverCaller     // Read-only binding to the contract
	ResolverTransactor // Write-only binding to the contract
	ResolverFilterer   // Log filterer for contract events
}

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

func DeployResolver 

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

DeployResolver deploys a new Ethereum contract, binding an instance of Resolver to it.

func NewResolver 

func NewResolver(address common.Address, backend bind.ContractBackend) (*Resolver, error)

NewResolver creates a new instance of Resolver, bound to a specific deployed contract.

type ResolverCaller 

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

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

func NewResolverCaller 

func NewResolverCaller(address common.Address, caller bind.ContractCaller) (*ResolverCaller, error)

NewResolverCaller creates a new read-only instance of Resolver, bound to a specific deployed contract.

func (*ResolverCaller) Addr 

func (_Resolver *ResolverCaller) Addr(opts *bind.CallOpts, node [32]byte) (common.Address, error)

Addr is a free data retrieval call binding the contract method 0x3b3b57de.

Solidity: function addr(bytes32 node) constant returns(address)

type ResolverCallerRaw 

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

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

func (*ResolverCallerRaw) Call 

func (_Resolver *ResolverCallerRaw) 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 ResolverCallerSession 

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

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

func (*ResolverCallerSession) Addr 

func (_Resolver *ResolverCallerSession) Addr(node [32]byte) (common.Address, error)

Addr is a free data retrieval call binding the contract method 0x3b3b57de.

Solidity: function addr(bytes32 node) constant returns(address)

type ResolverFilterer 

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

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

func NewResolverFilterer 

func NewResolverFilterer(address common.Address, filterer bind.ContractFilterer) (*ResolverFilterer, error)

NewResolverFilterer creates a new log filterer instance of Resolver, bound to a specific deployed contract.

type ResolverRaw 

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

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

func (*ResolverRaw) Call 

func (_Resolver *ResolverRaw) 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 (*ResolverRaw) Transact 

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

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

func (*ResolverRaw) Transfer 

func (_Resolver *ResolverRaw) 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 ResolverSession 

type ResolverSession struct {
	Contract     *Resolver         // 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
}

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

func (*ResolverSession) Addr 

func (_Resolver *ResolverSession) Addr(node [32]byte) (common.Address, error)

Addr is a free data retrieval call binding the contract method 0x3b3b57de.

Solidity: function addr(bytes32 node) constant returns(address)

type ResolverTransactor 

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

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

func NewResolverTransactor 

func NewResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*ResolverTransactor, error)

NewResolverTransactor creates a new write-only instance of Resolver, bound to a specific deployed contract.

type ResolverTransactorRaw 

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

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

func (*ResolverTransactorRaw) Transact 

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

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

func (*ResolverTransactorRaw) Transfer 

func (_Resolver *ResolverTransactorRaw) 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 ResolverTransactorSession 

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

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

type Root 

type Root struct {
	RootCaller     // Read-only binding to the contract
	RootTransactor // Write-only binding to the contract
	RootFilterer   // Log filterer for contract events
}

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

func DeployRoot 

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

DeployRoot deploys a new Ethereum contract, binding an instance of Root to it.

func NewRoot 

func NewRoot(address common.Address, backend bind.ContractBackend) (*Root, error)

NewRoot creates a new instance of Root, bound to a specific deployed contract.

type RootCaller 

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

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

func NewRootCaller 

func NewRootCaller(address common.Address, caller bind.ContractCaller) (*RootCaller, error)

NewRootCaller creates a new read-only instance of Root, bound to a specific deployed contract.

func (*RootCaller) Oracle 

func (_Root *RootCaller) Oracle(opts *bind.CallOpts) (common.Address, error)

Oracle is a free data retrieval call binding the contract method 0x7dc0d1d0.

Solidity: function oracle() constant returns(address)

func (*RootCaller) SupportsInterface 

func (_Root *RootCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error)

SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.

Solidity: function supportsInterface(bytes4 interfaceID) constant returns(bool)

type RootCallerRaw 

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

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

func (*RootCallerRaw) Call 

func (_Root *RootCallerRaw) 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 RootCallerSession 

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

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

func (*RootCallerSession) Oracle 

func (_Root *RootCallerSession) Oracle() (common.Address, error)

Oracle is a free data retrieval call binding the contract method 0x7dc0d1d0.

Solidity: function oracle() constant returns(address)

func (*RootCallerSession) SupportsInterface 

func (_Root *RootCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error)

SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.

Solidity: function supportsInterface(bytes4 interfaceID) constant returns(bool)

type RootFilterer 

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

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

func NewRootFilterer 

func NewRootFilterer(address common.Address, filterer bind.ContractFilterer) (*RootFilterer, error)

NewRootFilterer creates a new log filterer instance of Root, bound to a specific deployed contract.

type RootRaw 

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

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

func (*RootRaw) Call 

func (_Root *RootRaw) 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 (*RootRaw) Transact 

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

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

func (*RootRaw) Transfer 

func (_Root *RootRaw) 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 RootSession 

type RootSession struct {
	Contract     *Root             // 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
}

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

func (*RootSession) Oracle 

func (_Root *RootSession) Oracle() (common.Address, error)

Oracle is a free data retrieval call binding the contract method 0x7dc0d1d0.

Solidity: function oracle() constant returns(address)

func (*RootSession) ProveAndRegisterDefaultTLD 

func (_Root *RootSession) ProveAndRegisterDefaultTLD(name []byte, input []byte, proof []byte) (*types.Transaction, error)

ProveAndRegisterDefaultTLD is a paid mutator transaction binding the contract method 0x19f5b1e2.

Solidity: function proveAndRegisterDefaultTLD(bytes name, bytes input, bytes proof) returns()

func (*RootSession) ProveAndRegisterTLD 

func (_Root *RootSession) ProveAndRegisterTLD(name []byte, input []byte, proof []byte) (*types.Transaction, error)

ProveAndRegisterTLD is a paid mutator transaction binding the contract method 0x245b79ad.

Solidity: function proveAndRegisterTLD(bytes name, bytes input, bytes proof) returns()

func (*RootSession) RegisterTLD 

func (_Root *RootSession) RegisterTLD(name []byte, proof []byte) (*types.Transaction, error)

RegisterTLD is a paid mutator transaction binding the contract method 0x87900f20.

Solidity: function registerTLD(bytes name, bytes proof) returns()

func (*RootSession) SupportsInterface 

func (_Root *RootSession) SupportsInterface(interfaceID [4]byte) (bool, error)

SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.

Solidity: function supportsInterface(bytes4 interfaceID) constant returns(bool)

type RootTransactor 

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

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

func NewRootTransactor 

func NewRootTransactor(address common.Address, transactor bind.ContractTransactor) (*RootTransactor, error)

NewRootTransactor creates a new write-only instance of Root, bound to a specific deployed contract.

func (*RootTransactor) ProveAndRegisterDefaultTLD 

func (_Root *RootTransactor) ProveAndRegisterDefaultTLD(opts *bind.TransactOpts, name []byte, input []byte, proof []byte) (*types.Transaction, error)

ProveAndRegisterDefaultTLD is a paid mutator transaction binding the contract method 0x19f5b1e2.

Solidity: function proveAndRegisterDefaultTLD(bytes name, bytes input, bytes proof) returns()

func (*RootTransactor) ProveAndRegisterTLD 

func (_Root *RootTransactor) ProveAndRegisterTLD(opts *bind.TransactOpts, name []byte, input []byte, proof []byte) (*types.Transaction, error)

ProveAndRegisterTLD is a paid mutator transaction binding the contract method 0x245b79ad.

Solidity: function proveAndRegisterTLD(bytes name, bytes input, bytes proof) returns()

func (*RootTransactor) RegisterTLD 

func (_Root *RootTransactor) RegisterTLD(opts *bind.TransactOpts, name []byte, proof []byte) (*types.Transaction, error)

RegisterTLD is a paid mutator transaction binding the contract method 0x87900f20.

Solidity: function registerTLD(bytes name, bytes proof) returns()

type RootTransactorRaw 

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

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

func (*RootTransactorRaw) Transact 

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

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

func (*RootTransactorRaw) Transfer 

func (_Root *RootTransactorRaw) 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 RootTransactorSession 

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

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

func (*RootTransactorSession) ProveAndRegisterDefaultTLD 

func (_Root *RootTransactorSession) ProveAndRegisterDefaultTLD(name []byte, input []byte, proof []byte) (*types.Transaction, error)

ProveAndRegisterDefaultTLD is a paid mutator transaction binding the contract method 0x19f5b1e2.

Solidity: function proveAndRegisterDefaultTLD(bytes name, bytes input, bytes proof) returns()

func (*RootTransactorSession) ProveAndRegisterTLD 

func (_Root *RootTransactorSession) ProveAndRegisterTLD(name []byte, input []byte, proof []byte) (*types.Transaction, error)

ProveAndRegisterTLD is a paid mutator transaction binding the contract method 0x245b79ad.

Solidity: function proveAndRegisterTLD(bytes name, bytes input, bytes proof) returns()

func (*RootTransactorSession) RegisterTLD 

func (_Root *RootTransactorSession) RegisterTLD(name []byte, proof []byte) (*types.Transaction, error)

RegisterTLD is a paid mutator transaction binding the contract method 0x87900f20.

Solidity: function registerTLD(bytes name, bytes proof) 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.