10454 lines
441 KiB
Go
10454 lines
441 KiB
Go
// Code generated - DO NOT EDIT.
|
|
// This file is a generated binding and any manual changes will be lost.
|
|
|
|
package resolver
|
|
|
|
import (
|
|
"math/big"
|
|
"strings"
|
|
|
|
ethereum "github.com/ethereum/go-ethereum"
|
|
"github.com/ethereum/go-ethereum/accounts/abi"
|
|
"github.com/ethereum/go-ethereum/accounts/abi/bind"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/event"
|
|
)
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var (
|
|
_ = big.NewInt
|
|
_ = strings.NewReader
|
|
_ = ethereum.NotFound
|
|
_ = bind.Bind
|
|
_ = common.Big1
|
|
_ = types.BloomLookup
|
|
_ = event.NewSubscription
|
|
)
|
|
|
|
// ABIResolverABI is the input ABI used to generate the binding from.
|
|
const ABIResolverABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"contentTypes\",\"type\":\"uint256\"}],\"name\":\"ABI\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"},{\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"contentType\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"setABI\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"contentType\",\"type\":\"uint256\"}],\"name\":\"ABIChanged\",\"type\":\"event\"}]"
|
|
|
|
// ABIResolverFuncSigs maps the 4-byte function signature to its string representation.
|
|
var ABIResolverFuncSigs = map[string]string{
|
|
"2203ab56": "ABI(bytes32,uint256)",
|
|
"623195b0": "setABI(bytes32,uint256,bytes)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
}
|
|
|
|
// ABIResolver is an auto generated Go binding around an Ethereum contract.
|
|
type ABIResolver struct {
|
|
ABIResolverCaller // Read-only binding to the contract
|
|
ABIResolverTransactor // Write-only binding to the contract
|
|
ABIResolverFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// ABIResolverCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type ABIResolverCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ABIResolverTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type ABIResolverTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ABIResolverFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type ABIResolverFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ABIResolverSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type ABIResolverSession struct {
|
|
Contract *ABIResolver // 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
|
|
}
|
|
|
|
// ABIResolverCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type ABIResolverCallerSession struct {
|
|
Contract *ABIResolverCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// ABIResolverTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type ABIResolverTransactorSession struct {
|
|
Contract *ABIResolverTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// ABIResolverRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type ABIResolverRaw struct {
|
|
Contract *ABIResolver // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// ABIResolverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type ABIResolverCallerRaw struct {
|
|
Contract *ABIResolverCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// ABIResolverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type ABIResolverTransactorRaw struct {
|
|
Contract *ABIResolverTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewABIResolver creates a new instance of ABIResolver, bound to a specific deployed contract.
|
|
func NewABIResolver(address common.Address, backend bind.ContractBackend) (*ABIResolver, error) {
|
|
contract, err := bindABIResolver(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ABIResolver{ABIResolverCaller: ABIResolverCaller{contract: contract}, ABIResolverTransactor: ABIResolverTransactor{contract: contract}, ABIResolverFilterer: ABIResolverFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewABIResolverCaller creates a new read-only instance of ABIResolver, bound to a specific deployed contract.
|
|
func NewABIResolverCaller(address common.Address, caller bind.ContractCaller) (*ABIResolverCaller, error) {
|
|
contract, err := bindABIResolver(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ABIResolverCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewABIResolverTransactor creates a new write-only instance of ABIResolver, bound to a specific deployed contract.
|
|
func NewABIResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*ABIResolverTransactor, error) {
|
|
contract, err := bindABIResolver(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ABIResolverTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewABIResolverFilterer creates a new log filterer instance of ABIResolver, bound to a specific deployed contract.
|
|
func NewABIResolverFilterer(address common.Address, filterer bind.ContractFilterer) (*ABIResolverFilterer, error) {
|
|
contract, err := bindABIResolver(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ABIResolverFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindABIResolver binds a generic wrapper to an already deployed contract.
|
|
func bindABIResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(ABIResolverABI))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
|
|
}
|
|
|
|
// 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 (_ABIResolver *ABIResolverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ABIResolver.Contract.ABIResolverCaller.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_ABIResolver *ABIResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ABIResolver.Contract.ABIResolverTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ABIResolver *ABIResolverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ABIResolver.Contract.ABIResolverTransactor.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// 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 (_ABIResolver *ABIResolverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ABIResolver.Contract.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_ABIResolver *ABIResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ABIResolver.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ABIResolver *ABIResolverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ABIResolver.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// ABI is a free data retrieval call binding the contract method 0x2203ab56.
|
|
//
|
|
// Solidity: function ABI(bytes32 node, uint256 contentTypes) view returns(uint256, bytes)
|
|
func (_ABIResolver *ABIResolverCaller) ABI(opts *bind.CallOpts, node [32]byte, contentTypes *big.Int) (*big.Int, []byte, error) {
|
|
var out []interface{}
|
|
err := _ABIResolver.contract.Call(opts, &out, "ABI", node, contentTypes)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), *new([]byte), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
out1 := *abi.ConvertType(out[1], new([]byte)).(*[]byte)
|
|
|
|
return out0, out1, err
|
|
|
|
}
|
|
|
|
// ABI is a free data retrieval call binding the contract method 0x2203ab56.
|
|
//
|
|
// Solidity: function ABI(bytes32 node, uint256 contentTypes) view returns(uint256, bytes)
|
|
func (_ABIResolver *ABIResolverSession) ABI(node [32]byte, contentTypes *big.Int) (*big.Int, []byte, error) {
|
|
return _ABIResolver.Contract.ABI(&_ABIResolver.CallOpts, node, contentTypes)
|
|
}
|
|
|
|
// ABI is a free data retrieval call binding the contract method 0x2203ab56.
|
|
//
|
|
// Solidity: function ABI(bytes32 node, uint256 contentTypes) view returns(uint256, bytes)
|
|
func (_ABIResolver *ABIResolverCallerSession) ABI(node [32]byte, contentTypes *big.Int) (*big.Int, []byte, error) {
|
|
return _ABIResolver.Contract.ABI(&_ABIResolver.CallOpts, node, contentTypes)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_ABIResolver *ABIResolverCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _ABIResolver.contract.Call(opts, &out, "supportsInterface", interfaceID)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_ABIResolver *ABIResolverSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _ABIResolver.Contract.SupportsInterface(&_ABIResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_ABIResolver *ABIResolverCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _ABIResolver.Contract.SupportsInterface(&_ABIResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SetABI is a paid mutator transaction binding the contract method 0x623195b0.
|
|
//
|
|
// Solidity: function setABI(bytes32 node, uint256 contentType, bytes data) returns()
|
|
func (_ABIResolver *ABIResolverTransactor) SetABI(opts *bind.TransactOpts, node [32]byte, contentType *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _ABIResolver.contract.Transact(opts, "setABI", node, contentType, data)
|
|
}
|
|
|
|
// SetABI is a paid mutator transaction binding the contract method 0x623195b0.
|
|
//
|
|
// Solidity: function setABI(bytes32 node, uint256 contentType, bytes data) returns()
|
|
func (_ABIResolver *ABIResolverSession) SetABI(node [32]byte, contentType *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _ABIResolver.Contract.SetABI(&_ABIResolver.TransactOpts, node, contentType, data)
|
|
}
|
|
|
|
// SetABI is a paid mutator transaction binding the contract method 0x623195b0.
|
|
//
|
|
// Solidity: function setABI(bytes32 node, uint256 contentType, bytes data) returns()
|
|
func (_ABIResolver *ABIResolverTransactorSession) SetABI(node [32]byte, contentType *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _ABIResolver.Contract.SetABI(&_ABIResolver.TransactOpts, node, contentType, data)
|
|
}
|
|
|
|
// ABIResolverABIChangedIterator is returned from FilterABIChanged and is used to iterate over the raw logs and unpacked data for ABIChanged events raised by the ABIResolver contract.
|
|
type ABIResolverABIChangedIterator struct {
|
|
Event *ABIResolverABIChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ABIResolverABIChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ABIResolverABIChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ABIResolverABIChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ABIResolverABIChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ABIResolverABIChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ABIResolverABIChanged represents a ABIChanged event raised by the ABIResolver contract.
|
|
type ABIResolverABIChanged struct {
|
|
Node [32]byte
|
|
ContentType *big.Int
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterABIChanged is a free log retrieval operation binding the contract event 0xaa121bbeef5f32f5961a2a28966e769023910fc9479059ee3495d4c1a696efe3.
|
|
//
|
|
// Solidity: event ABIChanged(bytes32 indexed node, uint256 indexed contentType)
|
|
func (_ABIResolver *ABIResolverFilterer) FilterABIChanged(opts *bind.FilterOpts, node [][32]byte, contentType []*big.Int) (*ABIResolverABIChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var contentTypeRule []interface{}
|
|
for _, contentTypeItem := range contentType {
|
|
contentTypeRule = append(contentTypeRule, contentTypeItem)
|
|
}
|
|
|
|
logs, sub, err := _ABIResolver.contract.FilterLogs(opts, "ABIChanged", nodeRule, contentTypeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ABIResolverABIChangedIterator{contract: _ABIResolver.contract, event: "ABIChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchABIChanged is a free log subscription operation binding the contract event 0xaa121bbeef5f32f5961a2a28966e769023910fc9479059ee3495d4c1a696efe3.
|
|
//
|
|
// Solidity: event ABIChanged(bytes32 indexed node, uint256 indexed contentType)
|
|
func (_ABIResolver *ABIResolverFilterer) WatchABIChanged(opts *bind.WatchOpts, sink chan<- *ABIResolverABIChanged, node [][32]byte, contentType []*big.Int) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var contentTypeRule []interface{}
|
|
for _, contentTypeItem := range contentType {
|
|
contentTypeRule = append(contentTypeRule, contentTypeItem)
|
|
}
|
|
|
|
logs, sub, err := _ABIResolver.contract.WatchLogs(opts, "ABIChanged", nodeRule, contentTypeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ABIResolverABIChanged)
|
|
if err := _ABIResolver.contract.UnpackLog(event, "ABIChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseABIChanged is a log parse operation binding the contract event 0xaa121bbeef5f32f5961a2a28966e769023910fc9479059ee3495d4c1a696efe3.
|
|
//
|
|
// Solidity: event ABIChanged(bytes32 indexed node, uint256 indexed contentType)
|
|
func (_ABIResolver *ABIResolverFilterer) ParseABIChanged(log types.Log) (*ABIResolverABIChanged, error) {
|
|
event := new(ABIResolverABIChanged)
|
|
if err := _ABIResolver.contract.UnpackLog(event, "ABIChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// AddrResolverABI is the input ABI used to generate the binding from.
|
|
const AddrResolverABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"addr\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"coinType\",\"type\":\"uint256\"},{\"name\":\"a\",\"type\":\"bytes\"}],\"name\":\"setAddr\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"a\",\"type\":\"address\"}],\"name\":\"setAddr\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"coinType\",\"type\":\"uint256\"}],\"name\":\"addr\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"a\",\"type\":\"address\"}],\"name\":\"AddrChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"coinType\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"newAddress\",\"type\":\"bytes\"}],\"name\":\"AddressChanged\",\"type\":\"event\"}]"
|
|
|
|
// AddrResolverFuncSigs maps the 4-byte function signature to its string representation.
|
|
var AddrResolverFuncSigs = map[string]string{
|
|
"3b3b57de": "addr(bytes32)",
|
|
"f1cb7e06": "addr(bytes32,uint256)",
|
|
"d5fa2b00": "setAddr(bytes32,address)",
|
|
"8b95dd71": "setAddr(bytes32,uint256,bytes)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
}
|
|
|
|
// AddrResolver is an auto generated Go binding around an Ethereum contract.
|
|
type AddrResolver struct {
|
|
AddrResolverCaller // Read-only binding to the contract
|
|
AddrResolverTransactor // Write-only binding to the contract
|
|
AddrResolverFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// AddrResolverCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type AddrResolverCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// AddrResolverTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type AddrResolverTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// AddrResolverFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type AddrResolverFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// AddrResolverSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type AddrResolverSession struct {
|
|
Contract *AddrResolver // 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
|
|
}
|
|
|
|
// AddrResolverCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type AddrResolverCallerSession struct {
|
|
Contract *AddrResolverCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// AddrResolverTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type AddrResolverTransactorSession struct {
|
|
Contract *AddrResolverTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// AddrResolverRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type AddrResolverRaw struct {
|
|
Contract *AddrResolver // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// AddrResolverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type AddrResolverCallerRaw struct {
|
|
Contract *AddrResolverCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// AddrResolverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type AddrResolverTransactorRaw struct {
|
|
Contract *AddrResolverTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewAddrResolver creates a new instance of AddrResolver, bound to a specific deployed contract.
|
|
func NewAddrResolver(address common.Address, backend bind.ContractBackend) (*AddrResolver, error) {
|
|
contract, err := bindAddrResolver(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &AddrResolver{AddrResolverCaller: AddrResolverCaller{contract: contract}, AddrResolverTransactor: AddrResolverTransactor{contract: contract}, AddrResolverFilterer: AddrResolverFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewAddrResolverCaller creates a new read-only instance of AddrResolver, bound to a specific deployed contract.
|
|
func NewAddrResolverCaller(address common.Address, caller bind.ContractCaller) (*AddrResolverCaller, error) {
|
|
contract, err := bindAddrResolver(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &AddrResolverCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewAddrResolverTransactor creates a new write-only instance of AddrResolver, bound to a specific deployed contract.
|
|
func NewAddrResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*AddrResolverTransactor, error) {
|
|
contract, err := bindAddrResolver(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &AddrResolverTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewAddrResolverFilterer creates a new log filterer instance of AddrResolver, bound to a specific deployed contract.
|
|
func NewAddrResolverFilterer(address common.Address, filterer bind.ContractFilterer) (*AddrResolverFilterer, error) {
|
|
contract, err := bindAddrResolver(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &AddrResolverFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindAddrResolver binds a generic wrapper to an already deployed contract.
|
|
func bindAddrResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(AddrResolverABI))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
|
|
}
|
|
|
|
// 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 (_AddrResolver *AddrResolverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _AddrResolver.Contract.AddrResolverCaller.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_AddrResolver *AddrResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _AddrResolver.Contract.AddrResolverTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_AddrResolver *AddrResolverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _AddrResolver.Contract.AddrResolverTransactor.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// 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 (_AddrResolver *AddrResolverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _AddrResolver.Contract.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_AddrResolver *AddrResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _AddrResolver.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_AddrResolver *AddrResolverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _AddrResolver.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
|
|
//
|
|
// Solidity: function addr(bytes32 node) view returns(address)
|
|
func (_AddrResolver *AddrResolverCaller) Addr(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _AddrResolver.contract.Call(opts, &out, "addr", node)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
|
|
//
|
|
// Solidity: function addr(bytes32 node) view returns(address)
|
|
func (_AddrResolver *AddrResolverSession) Addr(node [32]byte) (common.Address, error) {
|
|
return _AddrResolver.Contract.Addr(&_AddrResolver.CallOpts, node)
|
|
}
|
|
|
|
// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
|
|
//
|
|
// Solidity: function addr(bytes32 node) view returns(address)
|
|
func (_AddrResolver *AddrResolverCallerSession) Addr(node [32]byte) (common.Address, error) {
|
|
return _AddrResolver.Contract.Addr(&_AddrResolver.CallOpts, node)
|
|
}
|
|
|
|
// Addr0 is a free data retrieval call binding the contract method 0xf1cb7e06.
|
|
//
|
|
// Solidity: function addr(bytes32 node, uint256 coinType) view returns(bytes)
|
|
func (_AddrResolver *AddrResolverCaller) Addr0(opts *bind.CallOpts, node [32]byte, coinType *big.Int) ([]byte, error) {
|
|
var out []interface{}
|
|
err := _AddrResolver.contract.Call(opts, &out, "addr0", node, coinType)
|
|
|
|
if err != nil {
|
|
return *new([]byte), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Addr0 is a free data retrieval call binding the contract method 0xf1cb7e06.
|
|
//
|
|
// Solidity: function addr(bytes32 node, uint256 coinType) view returns(bytes)
|
|
func (_AddrResolver *AddrResolverSession) Addr0(node [32]byte, coinType *big.Int) ([]byte, error) {
|
|
return _AddrResolver.Contract.Addr0(&_AddrResolver.CallOpts, node, coinType)
|
|
}
|
|
|
|
// Addr0 is a free data retrieval call binding the contract method 0xf1cb7e06.
|
|
//
|
|
// Solidity: function addr(bytes32 node, uint256 coinType) view returns(bytes)
|
|
func (_AddrResolver *AddrResolverCallerSession) Addr0(node [32]byte, coinType *big.Int) ([]byte, error) {
|
|
return _AddrResolver.Contract.Addr0(&_AddrResolver.CallOpts, node, coinType)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_AddrResolver *AddrResolverCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _AddrResolver.contract.Call(opts, &out, "supportsInterface", interfaceID)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_AddrResolver *AddrResolverSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _AddrResolver.Contract.SupportsInterface(&_AddrResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_AddrResolver *AddrResolverCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _AddrResolver.Contract.SupportsInterface(&_AddrResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SetAddr is a paid mutator transaction binding the contract method 0x8b95dd71.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, uint256 coinType, bytes a) returns()
|
|
func (_AddrResolver *AddrResolverTransactor) SetAddr(opts *bind.TransactOpts, node [32]byte, coinType *big.Int, a []byte) (*types.Transaction, error) {
|
|
return _AddrResolver.contract.Transact(opts, "setAddr", node, coinType, a)
|
|
}
|
|
|
|
// SetAddr is a paid mutator transaction binding the contract method 0x8b95dd71.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, uint256 coinType, bytes a) returns()
|
|
func (_AddrResolver *AddrResolverSession) SetAddr(node [32]byte, coinType *big.Int, a []byte) (*types.Transaction, error) {
|
|
return _AddrResolver.Contract.SetAddr(&_AddrResolver.TransactOpts, node, coinType, a)
|
|
}
|
|
|
|
// SetAddr is a paid mutator transaction binding the contract method 0x8b95dd71.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, uint256 coinType, bytes a) returns()
|
|
func (_AddrResolver *AddrResolverTransactorSession) SetAddr(node [32]byte, coinType *big.Int, a []byte) (*types.Transaction, error) {
|
|
return _AddrResolver.Contract.SetAddr(&_AddrResolver.TransactOpts, node, coinType, a)
|
|
}
|
|
|
|
// SetAddr0 is a paid mutator transaction binding the contract method 0xd5fa2b00.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, address a) returns()
|
|
func (_AddrResolver *AddrResolverTransactor) SetAddr0(opts *bind.TransactOpts, node [32]byte, a common.Address) (*types.Transaction, error) {
|
|
return _AddrResolver.contract.Transact(opts, "setAddr0", node, a)
|
|
}
|
|
|
|
// SetAddr0 is a paid mutator transaction binding the contract method 0xd5fa2b00.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, address a) returns()
|
|
func (_AddrResolver *AddrResolverSession) SetAddr0(node [32]byte, a common.Address) (*types.Transaction, error) {
|
|
return _AddrResolver.Contract.SetAddr0(&_AddrResolver.TransactOpts, node, a)
|
|
}
|
|
|
|
// SetAddr0 is a paid mutator transaction binding the contract method 0xd5fa2b00.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, address a) returns()
|
|
func (_AddrResolver *AddrResolverTransactorSession) SetAddr0(node [32]byte, a common.Address) (*types.Transaction, error) {
|
|
return _AddrResolver.Contract.SetAddr0(&_AddrResolver.TransactOpts, node, a)
|
|
}
|
|
|
|
// AddrResolverAddrChangedIterator is returned from FilterAddrChanged and is used to iterate over the raw logs and unpacked data for AddrChanged events raised by the AddrResolver contract.
|
|
type AddrResolverAddrChangedIterator struct {
|
|
Event *AddrResolverAddrChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *AddrResolverAddrChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(AddrResolverAddrChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(AddrResolverAddrChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *AddrResolverAddrChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *AddrResolverAddrChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// AddrResolverAddrChanged represents a AddrChanged event raised by the AddrResolver contract.
|
|
type AddrResolverAddrChanged struct {
|
|
Node [32]byte
|
|
A common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterAddrChanged is a free log retrieval operation binding the contract event 0x52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2.
|
|
//
|
|
// Solidity: event AddrChanged(bytes32 indexed node, address a)
|
|
func (_AddrResolver *AddrResolverFilterer) FilterAddrChanged(opts *bind.FilterOpts, node [][32]byte) (*AddrResolverAddrChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _AddrResolver.contract.FilterLogs(opts, "AddrChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &AddrResolverAddrChangedIterator{contract: _AddrResolver.contract, event: "AddrChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchAddrChanged is a free log subscription operation binding the contract event 0x52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2.
|
|
//
|
|
// Solidity: event AddrChanged(bytes32 indexed node, address a)
|
|
func (_AddrResolver *AddrResolverFilterer) WatchAddrChanged(opts *bind.WatchOpts, sink chan<- *AddrResolverAddrChanged, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _AddrResolver.contract.WatchLogs(opts, "AddrChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(AddrResolverAddrChanged)
|
|
if err := _AddrResolver.contract.UnpackLog(event, "AddrChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseAddrChanged is a log parse operation binding the contract event 0x52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2.
|
|
//
|
|
// Solidity: event AddrChanged(bytes32 indexed node, address a)
|
|
func (_AddrResolver *AddrResolverFilterer) ParseAddrChanged(log types.Log) (*AddrResolverAddrChanged, error) {
|
|
event := new(AddrResolverAddrChanged)
|
|
if err := _AddrResolver.contract.UnpackLog(event, "AddrChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// AddrResolverAddressChangedIterator is returned from FilterAddressChanged and is used to iterate over the raw logs and unpacked data for AddressChanged events raised by the AddrResolver contract.
|
|
type AddrResolverAddressChangedIterator struct {
|
|
Event *AddrResolverAddressChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *AddrResolverAddressChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(AddrResolverAddressChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(AddrResolverAddressChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *AddrResolverAddressChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *AddrResolverAddressChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// AddrResolverAddressChanged represents a AddressChanged event raised by the AddrResolver contract.
|
|
type AddrResolverAddressChanged struct {
|
|
Node [32]byte
|
|
CoinType *big.Int
|
|
NewAddress []byte
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterAddressChanged is a free log retrieval operation binding the contract event 0x65412581168e88a1e60c6459d7f44ae83ad0832e670826c05a4e2476b57af752.
|
|
//
|
|
// Solidity: event AddressChanged(bytes32 indexed node, uint256 coinType, bytes newAddress)
|
|
func (_AddrResolver *AddrResolverFilterer) FilterAddressChanged(opts *bind.FilterOpts, node [][32]byte) (*AddrResolverAddressChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _AddrResolver.contract.FilterLogs(opts, "AddressChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &AddrResolverAddressChangedIterator{contract: _AddrResolver.contract, event: "AddressChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchAddressChanged is a free log subscription operation binding the contract event 0x65412581168e88a1e60c6459d7f44ae83ad0832e670826c05a4e2476b57af752.
|
|
//
|
|
// Solidity: event AddressChanged(bytes32 indexed node, uint256 coinType, bytes newAddress)
|
|
func (_AddrResolver *AddrResolverFilterer) WatchAddressChanged(opts *bind.WatchOpts, sink chan<- *AddrResolverAddressChanged, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _AddrResolver.contract.WatchLogs(opts, "AddressChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(AddrResolverAddressChanged)
|
|
if err := _AddrResolver.contract.UnpackLog(event, "AddressChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseAddressChanged is a log parse operation binding the contract event 0x65412581168e88a1e60c6459d7f44ae83ad0832e670826c05a4e2476b57af752.
|
|
//
|
|
// Solidity: event AddressChanged(bytes32 indexed node, uint256 coinType, bytes newAddress)
|
|
func (_AddrResolver *AddrResolverFilterer) ParseAddressChanged(log types.Log) (*AddrResolverAddressChanged, error) {
|
|
event := new(AddrResolverAddressChanged)
|
|
if err := _AddrResolver.contract.UnpackLog(event, "AddressChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ContentHashResolverABI is the input ABI used to generate the binding from.
|
|
const ContentHashResolverABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"hash\",\"type\":\"bytes\"}],\"name\":\"setContenthash\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"contenthash\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"hash\",\"type\":\"bytes\"}],\"name\":\"ContenthashChanged\",\"type\":\"event\"}]"
|
|
|
|
// ContentHashResolverFuncSigs maps the 4-byte function signature to its string representation.
|
|
var ContentHashResolverFuncSigs = map[string]string{
|
|
"bc1c58d1": "contenthash(bytes32)",
|
|
"304e6ade": "setContenthash(bytes32,bytes)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
}
|
|
|
|
// ContentHashResolver is an auto generated Go binding around an Ethereum contract.
|
|
type ContentHashResolver struct {
|
|
ContentHashResolverCaller // Read-only binding to the contract
|
|
ContentHashResolverTransactor // Write-only binding to the contract
|
|
ContentHashResolverFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// ContentHashResolverCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type ContentHashResolverCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ContentHashResolverTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type ContentHashResolverTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ContentHashResolverFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type ContentHashResolverFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ContentHashResolverSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type ContentHashResolverSession struct {
|
|
Contract *ContentHashResolver // 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
|
|
}
|
|
|
|
// ContentHashResolverCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type ContentHashResolverCallerSession struct {
|
|
Contract *ContentHashResolverCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// ContentHashResolverTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type ContentHashResolverTransactorSession struct {
|
|
Contract *ContentHashResolverTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// ContentHashResolverRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type ContentHashResolverRaw struct {
|
|
Contract *ContentHashResolver // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// ContentHashResolverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type ContentHashResolverCallerRaw struct {
|
|
Contract *ContentHashResolverCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// ContentHashResolverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type ContentHashResolverTransactorRaw struct {
|
|
Contract *ContentHashResolverTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewContentHashResolver creates a new instance of ContentHashResolver, bound to a specific deployed contract.
|
|
func NewContentHashResolver(address common.Address, backend bind.ContractBackend) (*ContentHashResolver, error) {
|
|
contract, err := bindContentHashResolver(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ContentHashResolver{ContentHashResolverCaller: ContentHashResolverCaller{contract: contract}, ContentHashResolverTransactor: ContentHashResolverTransactor{contract: contract}, ContentHashResolverFilterer: ContentHashResolverFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewContentHashResolverCaller creates a new read-only instance of ContentHashResolver, bound to a specific deployed contract.
|
|
func NewContentHashResolverCaller(address common.Address, caller bind.ContractCaller) (*ContentHashResolverCaller, error) {
|
|
contract, err := bindContentHashResolver(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ContentHashResolverCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewContentHashResolverTransactor creates a new write-only instance of ContentHashResolver, bound to a specific deployed contract.
|
|
func NewContentHashResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*ContentHashResolverTransactor, error) {
|
|
contract, err := bindContentHashResolver(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ContentHashResolverTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewContentHashResolverFilterer creates a new log filterer instance of ContentHashResolver, bound to a specific deployed contract.
|
|
func NewContentHashResolverFilterer(address common.Address, filterer bind.ContractFilterer) (*ContentHashResolverFilterer, error) {
|
|
contract, err := bindContentHashResolver(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ContentHashResolverFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindContentHashResolver binds a generic wrapper to an already deployed contract.
|
|
func bindContentHashResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(ContentHashResolverABI))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
|
|
}
|
|
|
|
// 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 (_ContentHashResolver *ContentHashResolverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ContentHashResolver.Contract.ContentHashResolverCaller.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_ContentHashResolver *ContentHashResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ContentHashResolver.Contract.ContentHashResolverTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ContentHashResolver *ContentHashResolverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ContentHashResolver.Contract.ContentHashResolverTransactor.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// 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 (_ContentHashResolver *ContentHashResolverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ContentHashResolver.Contract.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_ContentHashResolver *ContentHashResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ContentHashResolver.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ContentHashResolver *ContentHashResolverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ContentHashResolver.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// Contenthash is a free data retrieval call binding the contract method 0xbc1c58d1.
|
|
//
|
|
// Solidity: function contenthash(bytes32 node) view returns(bytes)
|
|
func (_ContentHashResolver *ContentHashResolverCaller) Contenthash(opts *bind.CallOpts, node [32]byte) ([]byte, error) {
|
|
var out []interface{}
|
|
err := _ContentHashResolver.contract.Call(opts, &out, "contenthash", node)
|
|
|
|
if err != nil {
|
|
return *new([]byte), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Contenthash is a free data retrieval call binding the contract method 0xbc1c58d1.
|
|
//
|
|
// Solidity: function contenthash(bytes32 node) view returns(bytes)
|
|
func (_ContentHashResolver *ContentHashResolverSession) Contenthash(node [32]byte) ([]byte, error) {
|
|
return _ContentHashResolver.Contract.Contenthash(&_ContentHashResolver.CallOpts, node)
|
|
}
|
|
|
|
// Contenthash is a free data retrieval call binding the contract method 0xbc1c58d1.
|
|
//
|
|
// Solidity: function contenthash(bytes32 node) view returns(bytes)
|
|
func (_ContentHashResolver *ContentHashResolverCallerSession) Contenthash(node [32]byte) ([]byte, error) {
|
|
return _ContentHashResolver.Contract.Contenthash(&_ContentHashResolver.CallOpts, node)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_ContentHashResolver *ContentHashResolverCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _ContentHashResolver.contract.Call(opts, &out, "supportsInterface", interfaceID)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_ContentHashResolver *ContentHashResolverSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _ContentHashResolver.Contract.SupportsInterface(&_ContentHashResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_ContentHashResolver *ContentHashResolverCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _ContentHashResolver.Contract.SupportsInterface(&_ContentHashResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SetContenthash is a paid mutator transaction binding the contract method 0x304e6ade.
|
|
//
|
|
// Solidity: function setContenthash(bytes32 node, bytes hash) returns()
|
|
func (_ContentHashResolver *ContentHashResolverTransactor) SetContenthash(opts *bind.TransactOpts, node [32]byte, hash []byte) (*types.Transaction, error) {
|
|
return _ContentHashResolver.contract.Transact(opts, "setContenthash", node, hash)
|
|
}
|
|
|
|
// SetContenthash is a paid mutator transaction binding the contract method 0x304e6ade.
|
|
//
|
|
// Solidity: function setContenthash(bytes32 node, bytes hash) returns()
|
|
func (_ContentHashResolver *ContentHashResolverSession) SetContenthash(node [32]byte, hash []byte) (*types.Transaction, error) {
|
|
return _ContentHashResolver.Contract.SetContenthash(&_ContentHashResolver.TransactOpts, node, hash)
|
|
}
|
|
|
|
// SetContenthash is a paid mutator transaction binding the contract method 0x304e6ade.
|
|
//
|
|
// Solidity: function setContenthash(bytes32 node, bytes hash) returns()
|
|
func (_ContentHashResolver *ContentHashResolverTransactorSession) SetContenthash(node [32]byte, hash []byte) (*types.Transaction, error) {
|
|
return _ContentHashResolver.Contract.SetContenthash(&_ContentHashResolver.TransactOpts, node, hash)
|
|
}
|
|
|
|
// ContentHashResolverContenthashChangedIterator is returned from FilterContenthashChanged and is used to iterate over the raw logs and unpacked data for ContenthashChanged events raised by the ContentHashResolver contract.
|
|
type ContentHashResolverContenthashChangedIterator struct {
|
|
Event *ContentHashResolverContenthashChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ContentHashResolverContenthashChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ContentHashResolverContenthashChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ContentHashResolverContenthashChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ContentHashResolverContenthashChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ContentHashResolverContenthashChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ContentHashResolverContenthashChanged represents a ContenthashChanged event raised by the ContentHashResolver contract.
|
|
type ContentHashResolverContenthashChanged struct {
|
|
Node [32]byte
|
|
Hash []byte
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterContenthashChanged is a free log retrieval operation binding the contract event 0xe379c1624ed7e714cc0937528a32359d69d5281337765313dba4e081b72d7578.
|
|
//
|
|
// Solidity: event ContenthashChanged(bytes32 indexed node, bytes hash)
|
|
func (_ContentHashResolver *ContentHashResolverFilterer) FilterContenthashChanged(opts *bind.FilterOpts, node [][32]byte) (*ContentHashResolverContenthashChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ContentHashResolver.contract.FilterLogs(opts, "ContenthashChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ContentHashResolverContenthashChangedIterator{contract: _ContentHashResolver.contract, event: "ContenthashChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchContenthashChanged is a free log subscription operation binding the contract event 0xe379c1624ed7e714cc0937528a32359d69d5281337765313dba4e081b72d7578.
|
|
//
|
|
// Solidity: event ContenthashChanged(bytes32 indexed node, bytes hash)
|
|
func (_ContentHashResolver *ContentHashResolverFilterer) WatchContenthashChanged(opts *bind.WatchOpts, sink chan<- *ContentHashResolverContenthashChanged, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ContentHashResolver.contract.WatchLogs(opts, "ContenthashChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ContentHashResolverContenthashChanged)
|
|
if err := _ContentHashResolver.contract.UnpackLog(event, "ContenthashChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseContenthashChanged is a log parse operation binding the contract event 0xe379c1624ed7e714cc0937528a32359d69d5281337765313dba4e081b72d7578.
|
|
//
|
|
// Solidity: event ContenthashChanged(bytes32 indexed node, bytes hash)
|
|
func (_ContentHashResolver *ContentHashResolverFilterer) ParseContenthashChanged(log types.Log) (*ContentHashResolverContenthashChanged, error) {
|
|
event := new(ContentHashResolverContenthashChanged)
|
|
if err := _ContentHashResolver.contract.UnpackLog(event, "ContenthashChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// DNSResolverABI is the input ABI used to generate the binding from.
|
|
const DNSResolverABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"setDNSRecords\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"name\",\"type\":\"bytes32\"}],\"name\":\"hasDNSRecords\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"name\",\"type\":\"bytes32\"},{\"name\":\"resource\",\"type\":\"uint16\"}],\"name\":\"dnsRecord\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"clearDNSZone\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"name\",\"type\":\"bytes\"},{\"indexed\":false,\"name\":\"resource\",\"type\":\"uint16\"},{\"indexed\":false,\"name\":\"record\",\"type\":\"bytes\"}],\"name\":\"DNSRecordChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"name\",\"type\":\"bytes\"},{\"indexed\":false,\"name\":\"resource\",\"type\":\"uint16\"}],\"name\":\"DNSRecordDeleted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"DNSZoneCleared\",\"type\":\"event\"}]"
|
|
|
|
// DNSResolverFuncSigs maps the 4-byte function signature to its string representation.
|
|
var DNSResolverFuncSigs = map[string]string{
|
|
"ad5780af": "clearDNSZone(bytes32)",
|
|
"a8fa5682": "dnsRecord(bytes32,bytes32,uint16)",
|
|
"4cbf6ba4": "hasDNSRecords(bytes32,bytes32)",
|
|
"0af179d7": "setDNSRecords(bytes32,bytes)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
}
|
|
|
|
// DNSResolver is an auto generated Go binding around an Ethereum contract.
|
|
type DNSResolver struct {
|
|
DNSResolverCaller // Read-only binding to the contract
|
|
DNSResolverTransactor // Write-only binding to the contract
|
|
DNSResolverFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// DNSResolverCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type DNSResolverCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// DNSResolverTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type DNSResolverTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// DNSResolverFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type DNSResolverFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// DNSResolverSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type DNSResolverSession struct {
|
|
Contract *DNSResolver // 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
|
|
}
|
|
|
|
// DNSResolverCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type DNSResolverCallerSession struct {
|
|
Contract *DNSResolverCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// DNSResolverTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type DNSResolverTransactorSession struct {
|
|
Contract *DNSResolverTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// DNSResolverRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type DNSResolverRaw struct {
|
|
Contract *DNSResolver // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// DNSResolverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type DNSResolverCallerRaw struct {
|
|
Contract *DNSResolverCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// DNSResolverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type DNSResolverTransactorRaw struct {
|
|
Contract *DNSResolverTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewDNSResolver creates a new instance of DNSResolver, bound to a specific deployed contract.
|
|
func NewDNSResolver(address common.Address, backend bind.ContractBackend) (*DNSResolver, error) {
|
|
contract, err := bindDNSResolver(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &DNSResolver{DNSResolverCaller: DNSResolverCaller{contract: contract}, DNSResolverTransactor: DNSResolverTransactor{contract: contract}, DNSResolverFilterer: DNSResolverFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewDNSResolverCaller creates a new read-only instance of DNSResolver, bound to a specific deployed contract.
|
|
func NewDNSResolverCaller(address common.Address, caller bind.ContractCaller) (*DNSResolverCaller, error) {
|
|
contract, err := bindDNSResolver(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &DNSResolverCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewDNSResolverTransactor creates a new write-only instance of DNSResolver, bound to a specific deployed contract.
|
|
func NewDNSResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*DNSResolverTransactor, error) {
|
|
contract, err := bindDNSResolver(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &DNSResolverTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewDNSResolverFilterer creates a new log filterer instance of DNSResolver, bound to a specific deployed contract.
|
|
func NewDNSResolverFilterer(address common.Address, filterer bind.ContractFilterer) (*DNSResolverFilterer, error) {
|
|
contract, err := bindDNSResolver(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &DNSResolverFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindDNSResolver binds a generic wrapper to an already deployed contract.
|
|
func bindDNSResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(DNSResolverABI))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
|
|
}
|
|
|
|
// 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 (_DNSResolver *DNSResolverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _DNSResolver.Contract.DNSResolverCaller.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_DNSResolver *DNSResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _DNSResolver.Contract.DNSResolverTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_DNSResolver *DNSResolverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _DNSResolver.Contract.DNSResolverTransactor.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// 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 (_DNSResolver *DNSResolverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _DNSResolver.Contract.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_DNSResolver *DNSResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _DNSResolver.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_DNSResolver *DNSResolverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _DNSResolver.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// DnsRecord is a free data retrieval call binding the contract method 0xa8fa5682.
|
|
//
|
|
// Solidity: function dnsRecord(bytes32 node, bytes32 name, uint16 resource) view returns(bytes)
|
|
func (_DNSResolver *DNSResolverCaller) DnsRecord(opts *bind.CallOpts, node [32]byte, name [32]byte, resource uint16) ([]byte, error) {
|
|
var out []interface{}
|
|
err := _DNSResolver.contract.Call(opts, &out, "dnsRecord", node, name, resource)
|
|
|
|
if err != nil {
|
|
return *new([]byte), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// DnsRecord is a free data retrieval call binding the contract method 0xa8fa5682.
|
|
//
|
|
// Solidity: function dnsRecord(bytes32 node, bytes32 name, uint16 resource) view returns(bytes)
|
|
func (_DNSResolver *DNSResolverSession) DnsRecord(node [32]byte, name [32]byte, resource uint16) ([]byte, error) {
|
|
return _DNSResolver.Contract.DnsRecord(&_DNSResolver.CallOpts, node, name, resource)
|
|
}
|
|
|
|
// DnsRecord is a free data retrieval call binding the contract method 0xa8fa5682.
|
|
//
|
|
// Solidity: function dnsRecord(bytes32 node, bytes32 name, uint16 resource) view returns(bytes)
|
|
func (_DNSResolver *DNSResolverCallerSession) DnsRecord(node [32]byte, name [32]byte, resource uint16) ([]byte, error) {
|
|
return _DNSResolver.Contract.DnsRecord(&_DNSResolver.CallOpts, node, name, resource)
|
|
}
|
|
|
|
// HasDNSRecords is a free data retrieval call binding the contract method 0x4cbf6ba4.
|
|
//
|
|
// Solidity: function hasDNSRecords(bytes32 node, bytes32 name) view returns(bool)
|
|
func (_DNSResolver *DNSResolverCaller) HasDNSRecords(opts *bind.CallOpts, node [32]byte, name [32]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _DNSResolver.contract.Call(opts, &out, "hasDNSRecords", node, name)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// HasDNSRecords is a free data retrieval call binding the contract method 0x4cbf6ba4.
|
|
//
|
|
// Solidity: function hasDNSRecords(bytes32 node, bytes32 name) view returns(bool)
|
|
func (_DNSResolver *DNSResolverSession) HasDNSRecords(node [32]byte, name [32]byte) (bool, error) {
|
|
return _DNSResolver.Contract.HasDNSRecords(&_DNSResolver.CallOpts, node, name)
|
|
}
|
|
|
|
// HasDNSRecords is a free data retrieval call binding the contract method 0x4cbf6ba4.
|
|
//
|
|
// Solidity: function hasDNSRecords(bytes32 node, bytes32 name) view returns(bool)
|
|
func (_DNSResolver *DNSResolverCallerSession) HasDNSRecords(node [32]byte, name [32]byte) (bool, error) {
|
|
return _DNSResolver.Contract.HasDNSRecords(&_DNSResolver.CallOpts, node, name)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_DNSResolver *DNSResolverCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _DNSResolver.contract.Call(opts, &out, "supportsInterface", interfaceID)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_DNSResolver *DNSResolverSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _DNSResolver.Contract.SupportsInterface(&_DNSResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_DNSResolver *DNSResolverCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _DNSResolver.Contract.SupportsInterface(&_DNSResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// ClearDNSZone is a paid mutator transaction binding the contract method 0xad5780af.
|
|
//
|
|
// Solidity: function clearDNSZone(bytes32 node) returns()
|
|
func (_DNSResolver *DNSResolverTransactor) ClearDNSZone(opts *bind.TransactOpts, node [32]byte) (*types.Transaction, error) {
|
|
return _DNSResolver.contract.Transact(opts, "clearDNSZone", node)
|
|
}
|
|
|
|
// ClearDNSZone is a paid mutator transaction binding the contract method 0xad5780af.
|
|
//
|
|
// Solidity: function clearDNSZone(bytes32 node) returns()
|
|
func (_DNSResolver *DNSResolverSession) ClearDNSZone(node [32]byte) (*types.Transaction, error) {
|
|
return _DNSResolver.Contract.ClearDNSZone(&_DNSResolver.TransactOpts, node)
|
|
}
|
|
|
|
// ClearDNSZone is a paid mutator transaction binding the contract method 0xad5780af.
|
|
//
|
|
// Solidity: function clearDNSZone(bytes32 node) returns()
|
|
func (_DNSResolver *DNSResolverTransactorSession) ClearDNSZone(node [32]byte) (*types.Transaction, error) {
|
|
return _DNSResolver.Contract.ClearDNSZone(&_DNSResolver.TransactOpts, node)
|
|
}
|
|
|
|
// SetDNSRecords is a paid mutator transaction binding the contract method 0x0af179d7.
|
|
//
|
|
// Solidity: function setDNSRecords(bytes32 node, bytes data) returns()
|
|
func (_DNSResolver *DNSResolverTransactor) SetDNSRecords(opts *bind.TransactOpts, node [32]byte, data []byte) (*types.Transaction, error) {
|
|
return _DNSResolver.contract.Transact(opts, "setDNSRecords", node, data)
|
|
}
|
|
|
|
// SetDNSRecords is a paid mutator transaction binding the contract method 0x0af179d7.
|
|
//
|
|
// Solidity: function setDNSRecords(bytes32 node, bytes data) returns()
|
|
func (_DNSResolver *DNSResolverSession) SetDNSRecords(node [32]byte, data []byte) (*types.Transaction, error) {
|
|
return _DNSResolver.Contract.SetDNSRecords(&_DNSResolver.TransactOpts, node, data)
|
|
}
|
|
|
|
// SetDNSRecords is a paid mutator transaction binding the contract method 0x0af179d7.
|
|
//
|
|
// Solidity: function setDNSRecords(bytes32 node, bytes data) returns()
|
|
func (_DNSResolver *DNSResolverTransactorSession) SetDNSRecords(node [32]byte, data []byte) (*types.Transaction, error) {
|
|
return _DNSResolver.Contract.SetDNSRecords(&_DNSResolver.TransactOpts, node, data)
|
|
}
|
|
|
|
// DNSResolverDNSRecordChangedIterator is returned from FilterDNSRecordChanged and is used to iterate over the raw logs and unpacked data for DNSRecordChanged events raised by the DNSResolver contract.
|
|
type DNSResolverDNSRecordChangedIterator struct {
|
|
Event *DNSResolverDNSRecordChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *DNSResolverDNSRecordChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(DNSResolverDNSRecordChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(DNSResolverDNSRecordChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *DNSResolverDNSRecordChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *DNSResolverDNSRecordChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// DNSResolverDNSRecordChanged represents a DNSRecordChanged event raised by the DNSResolver contract.
|
|
type DNSResolverDNSRecordChanged struct {
|
|
Node [32]byte
|
|
Name []byte
|
|
Resource uint16
|
|
Record []byte
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterDNSRecordChanged is a free log retrieval operation binding the contract event 0x52a608b3303a48862d07a73d82fa221318c0027fbbcfb1b2329bface3f19ff2b.
|
|
//
|
|
// Solidity: event DNSRecordChanged(bytes32 indexed node, bytes name, uint16 resource, bytes record)
|
|
func (_DNSResolver *DNSResolverFilterer) FilterDNSRecordChanged(opts *bind.FilterOpts, node [][32]byte) (*DNSResolverDNSRecordChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _DNSResolver.contract.FilterLogs(opts, "DNSRecordChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &DNSResolverDNSRecordChangedIterator{contract: _DNSResolver.contract, event: "DNSRecordChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchDNSRecordChanged is a free log subscription operation binding the contract event 0x52a608b3303a48862d07a73d82fa221318c0027fbbcfb1b2329bface3f19ff2b.
|
|
//
|
|
// Solidity: event DNSRecordChanged(bytes32 indexed node, bytes name, uint16 resource, bytes record)
|
|
func (_DNSResolver *DNSResolverFilterer) WatchDNSRecordChanged(opts *bind.WatchOpts, sink chan<- *DNSResolverDNSRecordChanged, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _DNSResolver.contract.WatchLogs(opts, "DNSRecordChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(DNSResolverDNSRecordChanged)
|
|
if err := _DNSResolver.contract.UnpackLog(event, "DNSRecordChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseDNSRecordChanged is a log parse operation binding the contract event 0x52a608b3303a48862d07a73d82fa221318c0027fbbcfb1b2329bface3f19ff2b.
|
|
//
|
|
// Solidity: event DNSRecordChanged(bytes32 indexed node, bytes name, uint16 resource, bytes record)
|
|
func (_DNSResolver *DNSResolverFilterer) ParseDNSRecordChanged(log types.Log) (*DNSResolverDNSRecordChanged, error) {
|
|
event := new(DNSResolverDNSRecordChanged)
|
|
if err := _DNSResolver.contract.UnpackLog(event, "DNSRecordChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// DNSResolverDNSRecordDeletedIterator is returned from FilterDNSRecordDeleted and is used to iterate over the raw logs and unpacked data for DNSRecordDeleted events raised by the DNSResolver contract.
|
|
type DNSResolverDNSRecordDeletedIterator struct {
|
|
Event *DNSResolverDNSRecordDeleted // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *DNSResolverDNSRecordDeletedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(DNSResolverDNSRecordDeleted)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(DNSResolverDNSRecordDeleted)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *DNSResolverDNSRecordDeletedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *DNSResolverDNSRecordDeletedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// DNSResolverDNSRecordDeleted represents a DNSRecordDeleted event raised by the DNSResolver contract.
|
|
type DNSResolverDNSRecordDeleted struct {
|
|
Node [32]byte
|
|
Name []byte
|
|
Resource uint16
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterDNSRecordDeleted is a free log retrieval operation binding the contract event 0x03528ed0c2a3ebc993b12ce3c16bb382f9c7d88ef7d8a1bf290eaf35955a1207.
|
|
//
|
|
// Solidity: event DNSRecordDeleted(bytes32 indexed node, bytes name, uint16 resource)
|
|
func (_DNSResolver *DNSResolverFilterer) FilterDNSRecordDeleted(opts *bind.FilterOpts, node [][32]byte) (*DNSResolverDNSRecordDeletedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _DNSResolver.contract.FilterLogs(opts, "DNSRecordDeleted", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &DNSResolverDNSRecordDeletedIterator{contract: _DNSResolver.contract, event: "DNSRecordDeleted", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchDNSRecordDeleted is a free log subscription operation binding the contract event 0x03528ed0c2a3ebc993b12ce3c16bb382f9c7d88ef7d8a1bf290eaf35955a1207.
|
|
//
|
|
// Solidity: event DNSRecordDeleted(bytes32 indexed node, bytes name, uint16 resource)
|
|
func (_DNSResolver *DNSResolverFilterer) WatchDNSRecordDeleted(opts *bind.WatchOpts, sink chan<- *DNSResolverDNSRecordDeleted, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _DNSResolver.contract.WatchLogs(opts, "DNSRecordDeleted", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(DNSResolverDNSRecordDeleted)
|
|
if err := _DNSResolver.contract.UnpackLog(event, "DNSRecordDeleted", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseDNSRecordDeleted is a log parse operation binding the contract event 0x03528ed0c2a3ebc993b12ce3c16bb382f9c7d88ef7d8a1bf290eaf35955a1207.
|
|
//
|
|
// Solidity: event DNSRecordDeleted(bytes32 indexed node, bytes name, uint16 resource)
|
|
func (_DNSResolver *DNSResolverFilterer) ParseDNSRecordDeleted(log types.Log) (*DNSResolverDNSRecordDeleted, error) {
|
|
event := new(DNSResolverDNSRecordDeleted)
|
|
if err := _DNSResolver.contract.UnpackLog(event, "DNSRecordDeleted", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// DNSResolverDNSZoneClearedIterator is returned from FilterDNSZoneCleared and is used to iterate over the raw logs and unpacked data for DNSZoneCleared events raised by the DNSResolver contract.
|
|
type DNSResolverDNSZoneClearedIterator struct {
|
|
Event *DNSResolverDNSZoneCleared // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *DNSResolverDNSZoneClearedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(DNSResolverDNSZoneCleared)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(DNSResolverDNSZoneCleared)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *DNSResolverDNSZoneClearedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *DNSResolverDNSZoneClearedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// DNSResolverDNSZoneCleared represents a DNSZoneCleared event raised by the DNSResolver contract.
|
|
type DNSResolverDNSZoneCleared struct {
|
|
Node [32]byte
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterDNSZoneCleared is a free log retrieval operation binding the contract event 0xb757169b8492ca2f1c6619d9d76ce22803035c3b1d5f6930dffe7b127c1a1983.
|
|
//
|
|
// Solidity: event DNSZoneCleared(bytes32 indexed node)
|
|
func (_DNSResolver *DNSResolverFilterer) FilterDNSZoneCleared(opts *bind.FilterOpts, node [][32]byte) (*DNSResolverDNSZoneClearedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _DNSResolver.contract.FilterLogs(opts, "DNSZoneCleared", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &DNSResolverDNSZoneClearedIterator{contract: _DNSResolver.contract, event: "DNSZoneCleared", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchDNSZoneCleared is a free log subscription operation binding the contract event 0xb757169b8492ca2f1c6619d9d76ce22803035c3b1d5f6930dffe7b127c1a1983.
|
|
//
|
|
// Solidity: event DNSZoneCleared(bytes32 indexed node)
|
|
func (_DNSResolver *DNSResolverFilterer) WatchDNSZoneCleared(opts *bind.WatchOpts, sink chan<- *DNSResolverDNSZoneCleared, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _DNSResolver.contract.WatchLogs(opts, "DNSZoneCleared", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(DNSResolverDNSZoneCleared)
|
|
if err := _DNSResolver.contract.UnpackLog(event, "DNSZoneCleared", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseDNSZoneCleared is a log parse operation binding the contract event 0xb757169b8492ca2f1c6619d9d76ce22803035c3b1d5f6930dffe7b127c1a1983.
|
|
//
|
|
// Solidity: event DNSZoneCleared(bytes32 indexed node)
|
|
func (_DNSResolver *DNSResolverFilterer) ParseDNSZoneCleared(log types.Log) (*DNSResolverDNSZoneCleared, error) {
|
|
event := new(DNSResolverDNSZoneCleared)
|
|
if err := _DNSResolver.contract.UnpackLog(event, "DNSZoneCleared", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ENSABI is the input ABI used to generate the binding from.
|
|
const ENSABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"resolver\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"label\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"setSubnodeOwner\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"setTTL\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"ttl\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"resolver\",\"type\":\"address\"}],\"name\":\"setResolver\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"setOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"label\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"resolver\",\"type\":\"address\"},{\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"setSubnodeRecord\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"operator\",\"type\":\"address\"},{\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"resolver\",\"type\":\"address\"},{\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"setRecord\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"recordExists\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"label\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"NewOwner\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"resolver\",\"type\":\"address\"}],\"name\":\"NewResolver\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"NewTTL\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"}]"
|
|
|
|
// ENSFuncSigs maps the 4-byte function signature to its string representation.
|
|
var ENSFuncSigs = map[string]string{
|
|
"e985e9c5": "isApprovedForAll(address,address)",
|
|
"02571be3": "owner(bytes32)",
|
|
"f79fe538": "recordExists(bytes32)",
|
|
"0178b8bf": "resolver(bytes32)",
|
|
"a22cb465": "setApprovalForAll(address,bool)",
|
|
"5b0fc9c3": "setOwner(bytes32,address)",
|
|
"cf408823": "setRecord(bytes32,address,address,uint64)",
|
|
"1896f70a": "setResolver(bytes32,address)",
|
|
"06ab5923": "setSubnodeOwner(bytes32,bytes32,address)",
|
|
"5ef2c7f0": "setSubnodeRecord(bytes32,bytes32,address,address,uint64)",
|
|
"14ab9038": "setTTL(bytes32,uint64)",
|
|
"16a25cbd": "ttl(bytes32)",
|
|
}
|
|
|
|
// ENS is an auto generated Go binding around an Ethereum contract.
|
|
type ENS struct {
|
|
ENSCaller // Read-only binding to the contract
|
|
ENSTransactor // Write-only binding to the contract
|
|
ENSFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// ENSCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type ENSCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ENSTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type ENSTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ENSFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type ENSFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ENSSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
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
|
|
}
|
|
|
|
// ENSCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type ENSCallerSession struct {
|
|
Contract *ENSCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// ENSTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
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
|
|
}
|
|
|
|
// ENSRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type ENSRaw struct {
|
|
Contract *ENS // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// ENSCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type ENSCallerRaw struct {
|
|
Contract *ENSCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// ENSTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type ENSTransactorRaw struct {
|
|
Contract *ENSTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewENS creates a new instance of ENS, bound to a specific deployed contract.
|
|
func NewENS(address common.Address, backend bind.ContractBackend) (*ENS, error) {
|
|
contract, err := bindENS(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENS{ENSCaller: ENSCaller{contract: contract}, ENSTransactor: ENSTransactor{contract: contract}, ENSFilterer: ENSFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewENSCaller creates a new read-only instance of ENS, bound to a specific deployed contract.
|
|
func NewENSCaller(address common.Address, caller bind.ContractCaller) (*ENSCaller, error) {
|
|
contract, err := bindENS(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewENSTransactor creates a new write-only instance of ENS, bound to a specific deployed contract.
|
|
func NewENSTransactor(address common.Address, transactor bind.ContractTransactor) (*ENSTransactor, error) {
|
|
contract, err := bindENS(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewENSFilterer creates a new log filterer instance of ENS, bound to a specific deployed contract.
|
|
func NewENSFilterer(address common.Address, filterer bind.ContractFilterer) (*ENSFilterer, error) {
|
|
contract, err := bindENS(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindENS binds a generic wrapper to an already deployed contract.
|
|
func bindENS(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(ENSABI))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
|
|
}
|
|
|
|
// 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 (_ENS *ENSRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ENS.Contract.ENSCaller.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_ENS *ENSRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ENS.Contract.ENSTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ENS *ENSRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ENS.Contract.ENSTransactor.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// 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 (_ENS *ENSCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ENS.Contract.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_ENS *ENSTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ENS.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ENS *ENSTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ENS.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ENS *ENSCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) {
|
|
var out []interface{}
|
|
err := _ENS.contract.Call(opts, &out, "isApprovedForAll", owner, operator)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ENS *ENSSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _ENS.Contract.IsApprovedForAll(&_ENS.CallOpts, owner, operator)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ENS *ENSCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _ENS.Contract.IsApprovedForAll(&_ENS.CallOpts, owner, operator)
|
|
}
|
|
|
|
// Owner is a free data retrieval call binding the contract method 0x02571be3.
|
|
//
|
|
// Solidity: function owner(bytes32 node) view returns(address)
|
|
func (_ENS *ENSCaller) Owner(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _ENS.contract.Call(opts, &out, "owner", node)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Owner is a free data retrieval call binding the contract method 0x02571be3.
|
|
//
|
|
// Solidity: function owner(bytes32 node) view returns(address)
|
|
func (_ENS *ENSSession) Owner(node [32]byte) (common.Address, error) {
|
|
return _ENS.Contract.Owner(&_ENS.CallOpts, node)
|
|
}
|
|
|
|
// Owner is a free data retrieval call binding the contract method 0x02571be3.
|
|
//
|
|
// Solidity: function owner(bytes32 node) view returns(address)
|
|
func (_ENS *ENSCallerSession) Owner(node [32]byte) (common.Address, error) {
|
|
return _ENS.Contract.Owner(&_ENS.CallOpts, node)
|
|
}
|
|
|
|
// RecordExists is a free data retrieval call binding the contract method 0xf79fe538.
|
|
//
|
|
// Solidity: function recordExists(bytes32 node) view returns(bool)
|
|
func (_ENS *ENSCaller) RecordExists(opts *bind.CallOpts, node [32]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _ENS.contract.Call(opts, &out, "recordExists", node)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// RecordExists is a free data retrieval call binding the contract method 0xf79fe538.
|
|
//
|
|
// Solidity: function recordExists(bytes32 node) view returns(bool)
|
|
func (_ENS *ENSSession) RecordExists(node [32]byte) (bool, error) {
|
|
return _ENS.Contract.RecordExists(&_ENS.CallOpts, node)
|
|
}
|
|
|
|
// RecordExists is a free data retrieval call binding the contract method 0xf79fe538.
|
|
//
|
|
// Solidity: function recordExists(bytes32 node) view returns(bool)
|
|
func (_ENS *ENSCallerSession) RecordExists(node [32]byte) (bool, error) {
|
|
return _ENS.Contract.RecordExists(&_ENS.CallOpts, node)
|
|
}
|
|
|
|
// Resolver is a free data retrieval call binding the contract method 0x0178b8bf.
|
|
//
|
|
// Solidity: function resolver(bytes32 node) view returns(address)
|
|
func (_ENS *ENSCaller) Resolver(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _ENS.contract.Call(opts, &out, "resolver", node)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Resolver is a free data retrieval call binding the contract method 0x0178b8bf.
|
|
//
|
|
// Solidity: function resolver(bytes32 node) view returns(address)
|
|
func (_ENS *ENSSession) Resolver(node [32]byte) (common.Address, error) {
|
|
return _ENS.Contract.Resolver(&_ENS.CallOpts, node)
|
|
}
|
|
|
|
// Resolver is a free data retrieval call binding the contract method 0x0178b8bf.
|
|
//
|
|
// Solidity: function resolver(bytes32 node) view returns(address)
|
|
func (_ENS *ENSCallerSession) Resolver(node [32]byte) (common.Address, error) {
|
|
return _ENS.Contract.Resolver(&_ENS.CallOpts, node)
|
|
}
|
|
|
|
// Ttl is a free data retrieval call binding the contract method 0x16a25cbd.
|
|
//
|
|
// Solidity: function ttl(bytes32 node) view returns(uint64)
|
|
func (_ENS *ENSCaller) Ttl(opts *bind.CallOpts, node [32]byte) (uint64, error) {
|
|
var out []interface{}
|
|
err := _ENS.contract.Call(opts, &out, "ttl", node)
|
|
|
|
if err != nil {
|
|
return *new(uint64), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Ttl is a free data retrieval call binding the contract method 0x16a25cbd.
|
|
//
|
|
// Solidity: function ttl(bytes32 node) view returns(uint64)
|
|
func (_ENS *ENSSession) Ttl(node [32]byte) (uint64, error) {
|
|
return _ENS.Contract.Ttl(&_ENS.CallOpts, node)
|
|
}
|
|
|
|
// Ttl is a free data retrieval call binding the contract method 0x16a25cbd.
|
|
//
|
|
// Solidity: function ttl(bytes32 node) view returns(uint64)
|
|
func (_ENS *ENSCallerSession) Ttl(node [32]byte) (uint64, error) {
|
|
return _ENS.Contract.Ttl(&_ENS.CallOpts, node)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool approved) returns()
|
|
func (_ENS *ENSTransactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ENS.contract.Transact(opts, "setApprovalForAll", operator, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool approved) returns()
|
|
func (_ENS *ENSSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ENS.Contract.SetApprovalForAll(&_ENS.TransactOpts, operator, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool approved) returns()
|
|
func (_ENS *ENSTransactorSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ENS.Contract.SetApprovalForAll(&_ENS.TransactOpts, operator, approved)
|
|
}
|
|
|
|
// SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.
|
|
//
|
|
// Solidity: function setOwner(bytes32 node, address owner) returns()
|
|
func (_ENS *ENSTransactor) SetOwner(opts *bind.TransactOpts, node [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENS.contract.Transact(opts, "setOwner", node, owner)
|
|
}
|
|
|
|
// SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.
|
|
//
|
|
// Solidity: function setOwner(bytes32 node, address owner) returns()
|
|
func (_ENS *ENSSession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENS.Contract.SetOwner(&_ENS.TransactOpts, node, owner)
|
|
}
|
|
|
|
// SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.
|
|
//
|
|
// Solidity: function setOwner(bytes32 node, address owner) returns()
|
|
func (_ENS *ENSTransactorSession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENS.Contract.SetOwner(&_ENS.TransactOpts, node, owner)
|
|
}
|
|
|
|
// SetRecord is a paid mutator transaction binding the contract method 0xcf408823.
|
|
//
|
|
// Solidity: function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENS *ENSTransactor) SetRecord(opts *bind.TransactOpts, node [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENS.contract.Transact(opts, "setRecord", node, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetRecord is a paid mutator transaction binding the contract method 0xcf408823.
|
|
//
|
|
// Solidity: function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENS *ENSSession) SetRecord(node [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENS.Contract.SetRecord(&_ENS.TransactOpts, node, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetRecord is a paid mutator transaction binding the contract method 0xcf408823.
|
|
//
|
|
// Solidity: function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENS *ENSTransactorSession) SetRecord(node [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENS.Contract.SetRecord(&_ENS.TransactOpts, node, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.
|
|
//
|
|
// Solidity: function setResolver(bytes32 node, address resolver) returns()
|
|
func (_ENS *ENSTransactor) SetResolver(opts *bind.TransactOpts, node [32]byte, resolver common.Address) (*types.Transaction, error) {
|
|
return _ENS.contract.Transact(opts, "setResolver", node, resolver)
|
|
}
|
|
|
|
// SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.
|
|
//
|
|
// Solidity: function setResolver(bytes32 node, address resolver) returns()
|
|
func (_ENS *ENSSession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error) {
|
|
return _ENS.Contract.SetResolver(&_ENS.TransactOpts, node, resolver)
|
|
}
|
|
|
|
// SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.
|
|
//
|
|
// Solidity: function setResolver(bytes32 node, address resolver) returns()
|
|
func (_ENS *ENSTransactorSession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error) {
|
|
return _ENS.Contract.SetResolver(&_ENS.TransactOpts, node, resolver)
|
|
}
|
|
|
|
// SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923.
|
|
//
|
|
// Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns(bytes32)
|
|
func (_ENS *ENSTransactor) SetSubnodeOwner(opts *bind.TransactOpts, node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENS.contract.Transact(opts, "setSubnodeOwner", node, label, owner)
|
|
}
|
|
|
|
// SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923.
|
|
//
|
|
// Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns(bytes32)
|
|
func (_ENS *ENSSession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENS.Contract.SetSubnodeOwner(&_ENS.TransactOpts, node, label, owner)
|
|
}
|
|
|
|
// SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923.
|
|
//
|
|
// Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns(bytes32)
|
|
func (_ENS *ENSTransactorSession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENS.Contract.SetSubnodeOwner(&_ENS.TransactOpts, node, label, owner)
|
|
}
|
|
|
|
// SetSubnodeRecord is a paid mutator transaction binding the contract method 0x5ef2c7f0.
|
|
//
|
|
// Solidity: function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENS *ENSTransactor) SetSubnodeRecord(opts *bind.TransactOpts, node [32]byte, label [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENS.contract.Transact(opts, "setSubnodeRecord", node, label, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetSubnodeRecord is a paid mutator transaction binding the contract method 0x5ef2c7f0.
|
|
//
|
|
// Solidity: function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENS *ENSSession) SetSubnodeRecord(node [32]byte, label [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENS.Contract.SetSubnodeRecord(&_ENS.TransactOpts, node, label, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetSubnodeRecord is a paid mutator transaction binding the contract method 0x5ef2c7f0.
|
|
//
|
|
// Solidity: function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENS *ENSTransactorSession) SetSubnodeRecord(node [32]byte, label [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENS.Contract.SetSubnodeRecord(&_ENS.TransactOpts, node, label, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetTTL is a paid mutator transaction binding the contract method 0x14ab9038.
|
|
//
|
|
// Solidity: function setTTL(bytes32 node, uint64 ttl) returns()
|
|
func (_ENS *ENSTransactor) SetTTL(opts *bind.TransactOpts, node [32]byte, ttl uint64) (*types.Transaction, error) {
|
|
return _ENS.contract.Transact(opts, "setTTL", node, ttl)
|
|
}
|
|
|
|
// SetTTL is a paid mutator transaction binding the contract method 0x14ab9038.
|
|
//
|
|
// Solidity: function setTTL(bytes32 node, uint64 ttl) returns()
|
|
func (_ENS *ENSSession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error) {
|
|
return _ENS.Contract.SetTTL(&_ENS.TransactOpts, node, ttl)
|
|
}
|
|
|
|
// SetTTL is a paid mutator transaction binding the contract method 0x14ab9038.
|
|
//
|
|
// Solidity: function setTTL(bytes32 node, uint64 ttl) returns()
|
|
func (_ENS *ENSTransactorSession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error) {
|
|
return _ENS.Contract.SetTTL(&_ENS.TransactOpts, node, ttl)
|
|
}
|
|
|
|
// ENSApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the ENS contract.
|
|
type ENSApprovalForAllIterator struct {
|
|
Event *ENSApprovalForAll // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ENSApprovalForAllIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSApprovalForAll)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSApprovalForAll)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ENSApprovalForAllIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ENSApprovalForAllIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ENSApprovalForAll represents a ApprovalForAll event raised by the ENS contract.
|
|
type ENSApprovalForAll struct {
|
|
Owner common.Address
|
|
Operator common.Address
|
|
Approved bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ENS *ENSFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ENSApprovalForAllIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _ENS.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSApprovalForAllIterator{contract: _ENS.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ENS *ENSFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ENSApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _ENS.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ENSApprovalForAll)
|
|
if err := _ENS.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ENS *ENSFilterer) ParseApprovalForAll(log types.Log) (*ENSApprovalForAll, error) {
|
|
event := new(ENSApprovalForAll)
|
|
if err := _ENS.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// 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.
|
|
type ENSNewOwnerIterator struct {
|
|
Event *ENSNewOwner // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ENSNewOwnerIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSNewOwner)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSNewOwner)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ENSNewOwnerIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ENSNewOwnerIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ENSNewOwner represents a NewOwner event raised by the ENS contract.
|
|
type ENSNewOwner struct {
|
|
Node [32]byte
|
|
Label [32]byte
|
|
Owner common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterNewOwner is a free log retrieval operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82.
|
|
//
|
|
// Solidity: event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner)
|
|
func (_ENS *ENSFilterer) FilterNewOwner(opts *bind.FilterOpts, node [][32]byte, label [][32]byte) (*ENSNewOwnerIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var labelRule []interface{}
|
|
for _, labelItem := range label {
|
|
labelRule = append(labelRule, labelItem)
|
|
}
|
|
|
|
logs, sub, err := _ENS.contract.FilterLogs(opts, "NewOwner", nodeRule, labelRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSNewOwnerIterator{contract: _ENS.contract, event: "NewOwner", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchNewOwner is a free log subscription operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82.
|
|
//
|
|
// Solidity: event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner)
|
|
func (_ENS *ENSFilterer) WatchNewOwner(opts *bind.WatchOpts, sink chan<- *ENSNewOwner, node [][32]byte, label [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var labelRule []interface{}
|
|
for _, labelItem := range label {
|
|
labelRule = append(labelRule, labelItem)
|
|
}
|
|
|
|
logs, sub, err := _ENS.contract.WatchLogs(opts, "NewOwner", nodeRule, labelRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ENSNewOwner)
|
|
if err := _ENS.contract.UnpackLog(event, "NewOwner", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseNewOwner is a log parse operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82.
|
|
//
|
|
// Solidity: event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner)
|
|
func (_ENS *ENSFilterer) ParseNewOwner(log types.Log) (*ENSNewOwner, error) {
|
|
event := new(ENSNewOwner)
|
|
if err := _ENS.contract.UnpackLog(event, "NewOwner", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// 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.
|
|
type ENSNewResolverIterator struct {
|
|
Event *ENSNewResolver // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ENSNewResolverIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSNewResolver)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSNewResolver)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ENSNewResolverIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ENSNewResolverIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ENSNewResolver represents a NewResolver event raised by the ENS contract.
|
|
type ENSNewResolver struct {
|
|
Node [32]byte
|
|
Resolver common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterNewResolver is a free log retrieval operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0.
|
|
//
|
|
// Solidity: event NewResolver(bytes32 indexed node, address resolver)
|
|
func (_ENS *ENSFilterer) FilterNewResolver(opts *bind.FilterOpts, node [][32]byte) (*ENSNewResolverIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENS.contract.FilterLogs(opts, "NewResolver", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSNewResolverIterator{contract: _ENS.contract, event: "NewResolver", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchNewResolver is a free log subscription operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0.
|
|
//
|
|
// Solidity: event NewResolver(bytes32 indexed node, address resolver)
|
|
func (_ENS *ENSFilterer) WatchNewResolver(opts *bind.WatchOpts, sink chan<- *ENSNewResolver, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENS.contract.WatchLogs(opts, "NewResolver", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ENSNewResolver)
|
|
if err := _ENS.contract.UnpackLog(event, "NewResolver", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseNewResolver is a log parse operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0.
|
|
//
|
|
// Solidity: event NewResolver(bytes32 indexed node, address resolver)
|
|
func (_ENS *ENSFilterer) ParseNewResolver(log types.Log) (*ENSNewResolver, error) {
|
|
event := new(ENSNewResolver)
|
|
if err := _ENS.contract.UnpackLog(event, "NewResolver", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// 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.
|
|
type ENSNewTTLIterator struct {
|
|
Event *ENSNewTTL // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ENSNewTTLIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSNewTTL)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSNewTTL)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ENSNewTTLIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ENSNewTTLIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ENSNewTTL represents a NewTTL event raised by the ENS contract.
|
|
type ENSNewTTL struct {
|
|
Node [32]byte
|
|
Ttl uint64
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterNewTTL is a free log retrieval operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68.
|
|
//
|
|
// Solidity: event NewTTL(bytes32 indexed node, uint64 ttl)
|
|
func (_ENS *ENSFilterer) FilterNewTTL(opts *bind.FilterOpts, node [][32]byte) (*ENSNewTTLIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENS.contract.FilterLogs(opts, "NewTTL", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSNewTTLIterator{contract: _ENS.contract, event: "NewTTL", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchNewTTL is a free log subscription operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68.
|
|
//
|
|
// Solidity: event NewTTL(bytes32 indexed node, uint64 ttl)
|
|
func (_ENS *ENSFilterer) WatchNewTTL(opts *bind.WatchOpts, sink chan<- *ENSNewTTL, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENS.contract.WatchLogs(opts, "NewTTL", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ENSNewTTL)
|
|
if err := _ENS.contract.UnpackLog(event, "NewTTL", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseNewTTL is a log parse operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68.
|
|
//
|
|
// Solidity: event NewTTL(bytes32 indexed node, uint64 ttl)
|
|
func (_ENS *ENSFilterer) ParseNewTTL(log types.Log) (*ENSNewTTL, error) {
|
|
event := new(ENSNewTTL)
|
|
if err := _ENS.contract.UnpackLog(event, "NewTTL", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// 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.
|
|
type ENSTransferIterator struct {
|
|
Event *ENSTransfer // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ENSTransferIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSTransfer)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSTransfer)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ENSTransferIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ENSTransferIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ENSTransfer represents a Transfer event raised by the ENS contract.
|
|
type ENSTransfer struct {
|
|
Node [32]byte
|
|
Owner common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterTransfer is a free log retrieval operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266.
|
|
//
|
|
// Solidity: event Transfer(bytes32 indexed node, address owner)
|
|
func (_ENS *ENSFilterer) FilterTransfer(opts *bind.FilterOpts, node [][32]byte) (*ENSTransferIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENS.contract.FilterLogs(opts, "Transfer", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSTransferIterator{contract: _ENS.contract, event: "Transfer", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchTransfer is a free log subscription operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266.
|
|
//
|
|
// Solidity: event Transfer(bytes32 indexed node, address owner)
|
|
func (_ENS *ENSFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ENSTransfer, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENS.contract.WatchLogs(opts, "Transfer", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ENSTransfer)
|
|
if err := _ENS.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseTransfer is a log parse operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266.
|
|
//
|
|
// Solidity: event Transfer(bytes32 indexed node, address owner)
|
|
func (_ENS *ENSFilterer) ParseTransfer(log types.Log) (*ENSTransfer, error) {
|
|
event := new(ENSTransfer)
|
|
if err := _ENS.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ENSRegistryABI is the input ABI used to generate the binding from.
|
|
const ENSRegistryABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"resolver\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"label\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"setSubnodeOwner\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"setTTL\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"ttl\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"resolver\",\"type\":\"address\"}],\"name\":\"setResolver\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"setOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"label\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"resolver\",\"type\":\"address\"},{\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"setSubnodeRecord\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"operator\",\"type\":\"address\"},{\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"resolver\",\"type\":\"address\"},{\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"setRecord\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"recordExists\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"label\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"NewOwner\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"resolver\",\"type\":\"address\"}],\"name\":\"NewResolver\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"NewTTL\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"}]"
|
|
|
|
// ENSRegistryFuncSigs maps the 4-byte function signature to its string representation.
|
|
var ENSRegistryFuncSigs = map[string]string{
|
|
"e985e9c5": "isApprovedForAll(address,address)",
|
|
"02571be3": "owner(bytes32)",
|
|
"f79fe538": "recordExists(bytes32)",
|
|
"0178b8bf": "resolver(bytes32)",
|
|
"a22cb465": "setApprovalForAll(address,bool)",
|
|
"5b0fc9c3": "setOwner(bytes32,address)",
|
|
"cf408823": "setRecord(bytes32,address,address,uint64)",
|
|
"1896f70a": "setResolver(bytes32,address)",
|
|
"06ab5923": "setSubnodeOwner(bytes32,bytes32,address)",
|
|
"5ef2c7f0": "setSubnodeRecord(bytes32,bytes32,address,address,uint64)",
|
|
"14ab9038": "setTTL(bytes32,uint64)",
|
|
"16a25cbd": "ttl(bytes32)",
|
|
}
|
|
|
|
// ENSRegistry is an auto generated Go binding around an Ethereum contract.
|
|
type ENSRegistry struct {
|
|
ENSRegistryCaller // Read-only binding to the contract
|
|
ENSRegistryTransactor // Write-only binding to the contract
|
|
ENSRegistryFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// ENSRegistryCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type ENSRegistryCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ENSRegistryTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type ENSRegistryTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ENSRegistryFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type ENSRegistryFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ENSRegistrySession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type ENSRegistrySession struct {
|
|
Contract *ENSRegistry // 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
|
|
}
|
|
|
|
// ENSRegistryCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type ENSRegistryCallerSession struct {
|
|
Contract *ENSRegistryCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// ENSRegistryTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type ENSRegistryTransactorSession struct {
|
|
Contract *ENSRegistryTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// ENSRegistryRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type ENSRegistryRaw struct {
|
|
Contract *ENSRegistry // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// ENSRegistryCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type ENSRegistryCallerRaw struct {
|
|
Contract *ENSRegistryCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// ENSRegistryTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type ENSRegistryTransactorRaw struct {
|
|
Contract *ENSRegistryTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewENSRegistry creates a new instance of ENSRegistry, bound to a specific deployed contract.
|
|
func NewENSRegistry(address common.Address, backend bind.ContractBackend) (*ENSRegistry, error) {
|
|
contract, err := bindENSRegistry(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistry{ENSRegistryCaller: ENSRegistryCaller{contract: contract}, ENSRegistryTransactor: ENSRegistryTransactor{contract: contract}, ENSRegistryFilterer: ENSRegistryFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewENSRegistryCaller creates a new read-only instance of ENSRegistry, bound to a specific deployed contract.
|
|
func NewENSRegistryCaller(address common.Address, caller bind.ContractCaller) (*ENSRegistryCaller, error) {
|
|
contract, err := bindENSRegistry(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewENSRegistryTransactor creates a new write-only instance of ENSRegistry, bound to a specific deployed contract.
|
|
func NewENSRegistryTransactor(address common.Address, transactor bind.ContractTransactor) (*ENSRegistryTransactor, error) {
|
|
contract, err := bindENSRegistry(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewENSRegistryFilterer creates a new log filterer instance of ENSRegistry, bound to a specific deployed contract.
|
|
func NewENSRegistryFilterer(address common.Address, filterer bind.ContractFilterer) (*ENSRegistryFilterer, error) {
|
|
contract, err := bindENSRegistry(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindENSRegistry binds a generic wrapper to an already deployed contract.
|
|
func bindENSRegistry(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(ENSRegistryABI))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
|
|
}
|
|
|
|
// 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 (_ENSRegistry *ENSRegistryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ENSRegistry.Contract.ENSRegistryCaller.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_ENSRegistry *ENSRegistryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.ENSRegistryTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ENSRegistry *ENSRegistryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.ENSRegistryTransactor.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// 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 (_ENSRegistry *ENSRegistryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ENSRegistry.Contract.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_ENSRegistry *ENSRegistryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ENSRegistry *ENSRegistryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ENSRegistry *ENSRegistryCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) {
|
|
var out []interface{}
|
|
err := _ENSRegistry.contract.Call(opts, &out, "isApprovedForAll", owner, operator)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ENSRegistry *ENSRegistrySession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _ENSRegistry.Contract.IsApprovedForAll(&_ENSRegistry.CallOpts, owner, operator)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ENSRegistry *ENSRegistryCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _ENSRegistry.Contract.IsApprovedForAll(&_ENSRegistry.CallOpts, owner, operator)
|
|
}
|
|
|
|
// Owner is a free data retrieval call binding the contract method 0x02571be3.
|
|
//
|
|
// Solidity: function owner(bytes32 node) view returns(address)
|
|
func (_ENSRegistry *ENSRegistryCaller) Owner(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _ENSRegistry.contract.Call(opts, &out, "owner", node)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Owner is a free data retrieval call binding the contract method 0x02571be3.
|
|
//
|
|
// Solidity: function owner(bytes32 node) view returns(address)
|
|
func (_ENSRegistry *ENSRegistrySession) Owner(node [32]byte) (common.Address, error) {
|
|
return _ENSRegistry.Contract.Owner(&_ENSRegistry.CallOpts, node)
|
|
}
|
|
|
|
// Owner is a free data retrieval call binding the contract method 0x02571be3.
|
|
//
|
|
// Solidity: function owner(bytes32 node) view returns(address)
|
|
func (_ENSRegistry *ENSRegistryCallerSession) Owner(node [32]byte) (common.Address, error) {
|
|
return _ENSRegistry.Contract.Owner(&_ENSRegistry.CallOpts, node)
|
|
}
|
|
|
|
// RecordExists is a free data retrieval call binding the contract method 0xf79fe538.
|
|
//
|
|
// Solidity: function recordExists(bytes32 node) view returns(bool)
|
|
func (_ENSRegistry *ENSRegistryCaller) RecordExists(opts *bind.CallOpts, node [32]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _ENSRegistry.contract.Call(opts, &out, "recordExists", node)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// RecordExists is a free data retrieval call binding the contract method 0xf79fe538.
|
|
//
|
|
// Solidity: function recordExists(bytes32 node) view returns(bool)
|
|
func (_ENSRegistry *ENSRegistrySession) RecordExists(node [32]byte) (bool, error) {
|
|
return _ENSRegistry.Contract.RecordExists(&_ENSRegistry.CallOpts, node)
|
|
}
|
|
|
|
// RecordExists is a free data retrieval call binding the contract method 0xf79fe538.
|
|
//
|
|
// Solidity: function recordExists(bytes32 node) view returns(bool)
|
|
func (_ENSRegistry *ENSRegistryCallerSession) RecordExists(node [32]byte) (bool, error) {
|
|
return _ENSRegistry.Contract.RecordExists(&_ENSRegistry.CallOpts, node)
|
|
}
|
|
|
|
// Resolver is a free data retrieval call binding the contract method 0x0178b8bf.
|
|
//
|
|
// Solidity: function resolver(bytes32 node) view returns(address)
|
|
func (_ENSRegistry *ENSRegistryCaller) Resolver(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _ENSRegistry.contract.Call(opts, &out, "resolver", node)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Resolver is a free data retrieval call binding the contract method 0x0178b8bf.
|
|
//
|
|
// Solidity: function resolver(bytes32 node) view returns(address)
|
|
func (_ENSRegistry *ENSRegistrySession) Resolver(node [32]byte) (common.Address, error) {
|
|
return _ENSRegistry.Contract.Resolver(&_ENSRegistry.CallOpts, node)
|
|
}
|
|
|
|
// Resolver is a free data retrieval call binding the contract method 0x0178b8bf.
|
|
//
|
|
// Solidity: function resolver(bytes32 node) view returns(address)
|
|
func (_ENSRegistry *ENSRegistryCallerSession) Resolver(node [32]byte) (common.Address, error) {
|
|
return _ENSRegistry.Contract.Resolver(&_ENSRegistry.CallOpts, node)
|
|
}
|
|
|
|
// Ttl is a free data retrieval call binding the contract method 0x16a25cbd.
|
|
//
|
|
// Solidity: function ttl(bytes32 node) view returns(uint64)
|
|
func (_ENSRegistry *ENSRegistryCaller) Ttl(opts *bind.CallOpts, node [32]byte) (uint64, error) {
|
|
var out []interface{}
|
|
err := _ENSRegistry.contract.Call(opts, &out, "ttl", node)
|
|
|
|
if err != nil {
|
|
return *new(uint64), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Ttl is a free data retrieval call binding the contract method 0x16a25cbd.
|
|
//
|
|
// Solidity: function ttl(bytes32 node) view returns(uint64)
|
|
func (_ENSRegistry *ENSRegistrySession) Ttl(node [32]byte) (uint64, error) {
|
|
return _ENSRegistry.Contract.Ttl(&_ENSRegistry.CallOpts, node)
|
|
}
|
|
|
|
// Ttl is a free data retrieval call binding the contract method 0x16a25cbd.
|
|
//
|
|
// Solidity: function ttl(bytes32 node) view returns(uint64)
|
|
func (_ENSRegistry *ENSRegistryCallerSession) Ttl(node [32]byte) (uint64, error) {
|
|
return _ENSRegistry.Contract.Ttl(&_ENSRegistry.CallOpts, node)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool approved) returns()
|
|
func (_ENSRegistry *ENSRegistryTransactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ENSRegistry.contract.Transact(opts, "setApprovalForAll", operator, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool approved) returns()
|
|
func (_ENSRegistry *ENSRegistrySession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.SetApprovalForAll(&_ENSRegistry.TransactOpts, operator, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool approved) returns()
|
|
func (_ENSRegistry *ENSRegistryTransactorSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.SetApprovalForAll(&_ENSRegistry.TransactOpts, operator, approved)
|
|
}
|
|
|
|
// SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.
|
|
//
|
|
// Solidity: function setOwner(bytes32 node, address owner) returns()
|
|
func (_ENSRegistry *ENSRegistryTransactor) SetOwner(opts *bind.TransactOpts, node [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistry.contract.Transact(opts, "setOwner", node, owner)
|
|
}
|
|
|
|
// SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.
|
|
//
|
|
// Solidity: function setOwner(bytes32 node, address owner) returns()
|
|
func (_ENSRegistry *ENSRegistrySession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.SetOwner(&_ENSRegistry.TransactOpts, node, owner)
|
|
}
|
|
|
|
// SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.
|
|
//
|
|
// Solidity: function setOwner(bytes32 node, address owner) returns()
|
|
func (_ENSRegistry *ENSRegistryTransactorSession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.SetOwner(&_ENSRegistry.TransactOpts, node, owner)
|
|
}
|
|
|
|
// SetRecord is a paid mutator transaction binding the contract method 0xcf408823.
|
|
//
|
|
// Solidity: function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENSRegistry *ENSRegistryTransactor) SetRecord(opts *bind.TransactOpts, node [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistry.contract.Transact(opts, "setRecord", node, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetRecord is a paid mutator transaction binding the contract method 0xcf408823.
|
|
//
|
|
// Solidity: function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENSRegistry *ENSRegistrySession) SetRecord(node [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.SetRecord(&_ENSRegistry.TransactOpts, node, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetRecord is a paid mutator transaction binding the contract method 0xcf408823.
|
|
//
|
|
// Solidity: function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENSRegistry *ENSRegistryTransactorSession) SetRecord(node [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.SetRecord(&_ENSRegistry.TransactOpts, node, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.
|
|
//
|
|
// Solidity: function setResolver(bytes32 node, address resolver) returns()
|
|
func (_ENSRegistry *ENSRegistryTransactor) SetResolver(opts *bind.TransactOpts, node [32]byte, resolver common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistry.contract.Transact(opts, "setResolver", node, resolver)
|
|
}
|
|
|
|
// SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.
|
|
//
|
|
// Solidity: function setResolver(bytes32 node, address resolver) returns()
|
|
func (_ENSRegistry *ENSRegistrySession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.SetResolver(&_ENSRegistry.TransactOpts, node, resolver)
|
|
}
|
|
|
|
// SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.
|
|
//
|
|
// Solidity: function setResolver(bytes32 node, address resolver) returns()
|
|
func (_ENSRegistry *ENSRegistryTransactorSession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.SetResolver(&_ENSRegistry.TransactOpts, node, resolver)
|
|
}
|
|
|
|
// SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923.
|
|
//
|
|
// Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns(bytes32)
|
|
func (_ENSRegistry *ENSRegistryTransactor) SetSubnodeOwner(opts *bind.TransactOpts, node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistry.contract.Transact(opts, "setSubnodeOwner", node, label, owner)
|
|
}
|
|
|
|
// SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923.
|
|
//
|
|
// Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns(bytes32)
|
|
func (_ENSRegistry *ENSRegistrySession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.SetSubnodeOwner(&_ENSRegistry.TransactOpts, node, label, owner)
|
|
}
|
|
|
|
// SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923.
|
|
//
|
|
// Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns(bytes32)
|
|
func (_ENSRegistry *ENSRegistryTransactorSession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.SetSubnodeOwner(&_ENSRegistry.TransactOpts, node, label, owner)
|
|
}
|
|
|
|
// SetSubnodeRecord is a paid mutator transaction binding the contract method 0x5ef2c7f0.
|
|
//
|
|
// Solidity: function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENSRegistry *ENSRegistryTransactor) SetSubnodeRecord(opts *bind.TransactOpts, node [32]byte, label [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistry.contract.Transact(opts, "setSubnodeRecord", node, label, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetSubnodeRecord is a paid mutator transaction binding the contract method 0x5ef2c7f0.
|
|
//
|
|
// Solidity: function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENSRegistry *ENSRegistrySession) SetSubnodeRecord(node [32]byte, label [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.SetSubnodeRecord(&_ENSRegistry.TransactOpts, node, label, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetSubnodeRecord is a paid mutator transaction binding the contract method 0x5ef2c7f0.
|
|
//
|
|
// Solidity: function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENSRegistry *ENSRegistryTransactorSession) SetSubnodeRecord(node [32]byte, label [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.SetSubnodeRecord(&_ENSRegistry.TransactOpts, node, label, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetTTL is a paid mutator transaction binding the contract method 0x14ab9038.
|
|
//
|
|
// Solidity: function setTTL(bytes32 node, uint64 ttl) returns()
|
|
func (_ENSRegistry *ENSRegistryTransactor) SetTTL(opts *bind.TransactOpts, node [32]byte, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistry.contract.Transact(opts, "setTTL", node, ttl)
|
|
}
|
|
|
|
// SetTTL is a paid mutator transaction binding the contract method 0x14ab9038.
|
|
//
|
|
// Solidity: function setTTL(bytes32 node, uint64 ttl) returns()
|
|
func (_ENSRegistry *ENSRegistrySession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.SetTTL(&_ENSRegistry.TransactOpts, node, ttl)
|
|
}
|
|
|
|
// SetTTL is a paid mutator transaction binding the contract method 0x14ab9038.
|
|
//
|
|
// Solidity: function setTTL(bytes32 node, uint64 ttl) returns()
|
|
func (_ENSRegistry *ENSRegistryTransactorSession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistry.Contract.SetTTL(&_ENSRegistry.TransactOpts, node, ttl)
|
|
}
|
|
|
|
// ENSRegistryApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the ENSRegistry contract.
|
|
type ENSRegistryApprovalForAllIterator struct {
|
|
Event *ENSRegistryApprovalForAll // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ENSRegistryApprovalForAllIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryApprovalForAll)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryApprovalForAll)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ENSRegistryApprovalForAllIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ENSRegistryApprovalForAllIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ENSRegistryApprovalForAll represents a ApprovalForAll event raised by the ENSRegistry contract.
|
|
type ENSRegistryApprovalForAll struct {
|
|
Owner common.Address
|
|
Operator common.Address
|
|
Approved bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ENSRegistry *ENSRegistryFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ENSRegistryApprovalForAllIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistry.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryApprovalForAllIterator{contract: _ENSRegistry.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ENSRegistry *ENSRegistryFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ENSRegistryApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistry.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ENSRegistryApprovalForAll)
|
|
if err := _ENSRegistry.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ENSRegistry *ENSRegistryFilterer) ParseApprovalForAll(log types.Log) (*ENSRegistryApprovalForAll, error) {
|
|
event := new(ENSRegistryApprovalForAll)
|
|
if err := _ENSRegistry.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ENSRegistryNewOwnerIterator is returned from FilterNewOwner and is used to iterate over the raw logs and unpacked data for NewOwner events raised by the ENSRegistry contract.
|
|
type ENSRegistryNewOwnerIterator struct {
|
|
Event *ENSRegistryNewOwner // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ENSRegistryNewOwnerIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryNewOwner)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryNewOwner)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ENSRegistryNewOwnerIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ENSRegistryNewOwnerIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ENSRegistryNewOwner represents a NewOwner event raised by the ENSRegistry contract.
|
|
type ENSRegistryNewOwner struct {
|
|
Node [32]byte
|
|
Label [32]byte
|
|
Owner common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterNewOwner is a free log retrieval operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82.
|
|
//
|
|
// Solidity: event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner)
|
|
func (_ENSRegistry *ENSRegistryFilterer) FilterNewOwner(opts *bind.FilterOpts, node [][32]byte, label [][32]byte) (*ENSRegistryNewOwnerIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var labelRule []interface{}
|
|
for _, labelItem := range label {
|
|
labelRule = append(labelRule, labelItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistry.contract.FilterLogs(opts, "NewOwner", nodeRule, labelRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryNewOwnerIterator{contract: _ENSRegistry.contract, event: "NewOwner", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchNewOwner is a free log subscription operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82.
|
|
//
|
|
// Solidity: event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner)
|
|
func (_ENSRegistry *ENSRegistryFilterer) WatchNewOwner(opts *bind.WatchOpts, sink chan<- *ENSRegistryNewOwner, node [][32]byte, label [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var labelRule []interface{}
|
|
for _, labelItem := range label {
|
|
labelRule = append(labelRule, labelItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistry.contract.WatchLogs(opts, "NewOwner", nodeRule, labelRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ENSRegistryNewOwner)
|
|
if err := _ENSRegistry.contract.UnpackLog(event, "NewOwner", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseNewOwner is a log parse operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82.
|
|
//
|
|
// Solidity: event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner)
|
|
func (_ENSRegistry *ENSRegistryFilterer) ParseNewOwner(log types.Log) (*ENSRegistryNewOwner, error) {
|
|
event := new(ENSRegistryNewOwner)
|
|
if err := _ENSRegistry.contract.UnpackLog(event, "NewOwner", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ENSRegistryNewResolverIterator is returned from FilterNewResolver and is used to iterate over the raw logs and unpacked data for NewResolver events raised by the ENSRegistry contract.
|
|
type ENSRegistryNewResolverIterator struct {
|
|
Event *ENSRegistryNewResolver // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ENSRegistryNewResolverIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryNewResolver)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryNewResolver)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ENSRegistryNewResolverIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ENSRegistryNewResolverIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ENSRegistryNewResolver represents a NewResolver event raised by the ENSRegistry contract.
|
|
type ENSRegistryNewResolver struct {
|
|
Node [32]byte
|
|
Resolver common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterNewResolver is a free log retrieval operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0.
|
|
//
|
|
// Solidity: event NewResolver(bytes32 indexed node, address resolver)
|
|
func (_ENSRegistry *ENSRegistryFilterer) FilterNewResolver(opts *bind.FilterOpts, node [][32]byte) (*ENSRegistryNewResolverIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistry.contract.FilterLogs(opts, "NewResolver", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryNewResolverIterator{contract: _ENSRegistry.contract, event: "NewResolver", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchNewResolver is a free log subscription operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0.
|
|
//
|
|
// Solidity: event NewResolver(bytes32 indexed node, address resolver)
|
|
func (_ENSRegistry *ENSRegistryFilterer) WatchNewResolver(opts *bind.WatchOpts, sink chan<- *ENSRegistryNewResolver, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistry.contract.WatchLogs(opts, "NewResolver", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ENSRegistryNewResolver)
|
|
if err := _ENSRegistry.contract.UnpackLog(event, "NewResolver", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseNewResolver is a log parse operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0.
|
|
//
|
|
// Solidity: event NewResolver(bytes32 indexed node, address resolver)
|
|
func (_ENSRegistry *ENSRegistryFilterer) ParseNewResolver(log types.Log) (*ENSRegistryNewResolver, error) {
|
|
event := new(ENSRegistryNewResolver)
|
|
if err := _ENSRegistry.contract.UnpackLog(event, "NewResolver", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ENSRegistryNewTTLIterator is returned from FilterNewTTL and is used to iterate over the raw logs and unpacked data for NewTTL events raised by the ENSRegistry contract.
|
|
type ENSRegistryNewTTLIterator struct {
|
|
Event *ENSRegistryNewTTL // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ENSRegistryNewTTLIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryNewTTL)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryNewTTL)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ENSRegistryNewTTLIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ENSRegistryNewTTLIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ENSRegistryNewTTL represents a NewTTL event raised by the ENSRegistry contract.
|
|
type ENSRegistryNewTTL struct {
|
|
Node [32]byte
|
|
Ttl uint64
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterNewTTL is a free log retrieval operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68.
|
|
//
|
|
// Solidity: event NewTTL(bytes32 indexed node, uint64 ttl)
|
|
func (_ENSRegistry *ENSRegistryFilterer) FilterNewTTL(opts *bind.FilterOpts, node [][32]byte) (*ENSRegistryNewTTLIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistry.contract.FilterLogs(opts, "NewTTL", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryNewTTLIterator{contract: _ENSRegistry.contract, event: "NewTTL", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchNewTTL is a free log subscription operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68.
|
|
//
|
|
// Solidity: event NewTTL(bytes32 indexed node, uint64 ttl)
|
|
func (_ENSRegistry *ENSRegistryFilterer) WatchNewTTL(opts *bind.WatchOpts, sink chan<- *ENSRegistryNewTTL, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistry.contract.WatchLogs(opts, "NewTTL", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ENSRegistryNewTTL)
|
|
if err := _ENSRegistry.contract.UnpackLog(event, "NewTTL", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseNewTTL is a log parse operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68.
|
|
//
|
|
// Solidity: event NewTTL(bytes32 indexed node, uint64 ttl)
|
|
func (_ENSRegistry *ENSRegistryFilterer) ParseNewTTL(log types.Log) (*ENSRegistryNewTTL, error) {
|
|
event := new(ENSRegistryNewTTL)
|
|
if err := _ENSRegistry.contract.UnpackLog(event, "NewTTL", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ENSRegistryTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ENSRegistry contract.
|
|
type ENSRegistryTransferIterator struct {
|
|
Event *ENSRegistryTransfer // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ENSRegistryTransferIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryTransfer)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryTransfer)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ENSRegistryTransferIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ENSRegistryTransferIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ENSRegistryTransfer represents a Transfer event raised by the ENSRegistry contract.
|
|
type ENSRegistryTransfer struct {
|
|
Node [32]byte
|
|
Owner common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterTransfer is a free log retrieval operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266.
|
|
//
|
|
// Solidity: event Transfer(bytes32 indexed node, address owner)
|
|
func (_ENSRegistry *ENSRegistryFilterer) FilterTransfer(opts *bind.FilterOpts, node [][32]byte) (*ENSRegistryTransferIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistry.contract.FilterLogs(opts, "Transfer", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryTransferIterator{contract: _ENSRegistry.contract, event: "Transfer", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchTransfer is a free log subscription operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266.
|
|
//
|
|
// Solidity: event Transfer(bytes32 indexed node, address owner)
|
|
func (_ENSRegistry *ENSRegistryFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ENSRegistryTransfer, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistry.contract.WatchLogs(opts, "Transfer", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ENSRegistryTransfer)
|
|
if err := _ENSRegistry.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseTransfer is a log parse operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266.
|
|
//
|
|
// Solidity: event Transfer(bytes32 indexed node, address owner)
|
|
func (_ENSRegistry *ENSRegistryFilterer) ParseTransfer(log types.Log) (*ENSRegistryTransfer, error) {
|
|
event := new(ENSRegistryTransfer)
|
|
if err := _ENSRegistry.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ENSRegistryWithFallbackABI is the input ABI used to generate the binding from.
|
|
const ENSRegistryWithFallbackABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"resolver\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"label\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"setSubnodeOwner\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"setTTL\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"ttl\",\"outputs\":[{\"name\":\"\",\"type\":\"uint64\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"resolver\",\"type\":\"address\"}],\"name\":\"setResolver\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"setOwner\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"label\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"resolver\",\"type\":\"address\"},{\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"setSubnodeRecord\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"operator\",\"type\":\"address\"},{\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"resolver\",\"type\":\"address\"},{\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"setRecord\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"recordExists\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"label\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"NewOwner\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"resolver\",\"type\":\"address\"}],\"name\":\"NewResolver\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"ttl\",\"type\":\"uint64\"}],\"name\":\"NewTTL\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"}]"
|
|
|
|
// ENSRegistryWithFallbackFuncSigs maps the 4-byte function signature to its string representation.
|
|
var ENSRegistryWithFallbackFuncSigs = map[string]string{
|
|
"e985e9c5": "isApprovedForAll(address,address)",
|
|
"02571be3": "owner(bytes32)",
|
|
"f79fe538": "recordExists(bytes32)",
|
|
"0178b8bf": "resolver(bytes32)",
|
|
"a22cb465": "setApprovalForAll(address,bool)",
|
|
"5b0fc9c3": "setOwner(bytes32,address)",
|
|
"cf408823": "setRecord(bytes32,address,address,uint64)",
|
|
"1896f70a": "setResolver(bytes32,address)",
|
|
"06ab5923": "setSubnodeOwner(bytes32,bytes32,address)",
|
|
"5ef2c7f0": "setSubnodeRecord(bytes32,bytes32,address,address,uint64)",
|
|
"14ab9038": "setTTL(bytes32,uint64)",
|
|
"16a25cbd": "ttl(bytes32)",
|
|
}
|
|
|
|
// ENSRegistryWithFallback is an auto generated Go binding around an Ethereum contract.
|
|
type ENSRegistryWithFallback struct {
|
|
ENSRegistryWithFallbackCaller // Read-only binding to the contract
|
|
ENSRegistryWithFallbackTransactor // Write-only binding to the contract
|
|
ENSRegistryWithFallbackFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// ENSRegistryWithFallbackCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type ENSRegistryWithFallbackCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ENSRegistryWithFallbackTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type ENSRegistryWithFallbackTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ENSRegistryWithFallbackFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type ENSRegistryWithFallbackFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ENSRegistryWithFallbackSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type ENSRegistryWithFallbackSession struct {
|
|
Contract *ENSRegistryWithFallback // 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
|
|
}
|
|
|
|
// ENSRegistryWithFallbackCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type ENSRegistryWithFallbackCallerSession struct {
|
|
Contract *ENSRegistryWithFallbackCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// ENSRegistryWithFallbackTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type ENSRegistryWithFallbackTransactorSession struct {
|
|
Contract *ENSRegistryWithFallbackTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// ENSRegistryWithFallbackRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type ENSRegistryWithFallbackRaw struct {
|
|
Contract *ENSRegistryWithFallback // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// ENSRegistryWithFallbackCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type ENSRegistryWithFallbackCallerRaw struct {
|
|
Contract *ENSRegistryWithFallbackCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// ENSRegistryWithFallbackTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type ENSRegistryWithFallbackTransactorRaw struct {
|
|
Contract *ENSRegistryWithFallbackTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewENSRegistryWithFallback creates a new instance of ENSRegistryWithFallback, bound to a specific deployed contract.
|
|
func NewENSRegistryWithFallback(address common.Address, backend bind.ContractBackend) (*ENSRegistryWithFallback, error) {
|
|
contract, err := bindENSRegistryWithFallback(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryWithFallback{ENSRegistryWithFallbackCaller: ENSRegistryWithFallbackCaller{contract: contract}, ENSRegistryWithFallbackTransactor: ENSRegistryWithFallbackTransactor{contract: contract}, ENSRegistryWithFallbackFilterer: ENSRegistryWithFallbackFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewENSRegistryWithFallbackCaller creates a new read-only instance of ENSRegistryWithFallback, bound to a specific deployed contract.
|
|
func NewENSRegistryWithFallbackCaller(address common.Address, caller bind.ContractCaller) (*ENSRegistryWithFallbackCaller, error) {
|
|
contract, err := bindENSRegistryWithFallback(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryWithFallbackCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewENSRegistryWithFallbackTransactor creates a new write-only instance of ENSRegistryWithFallback, bound to a specific deployed contract.
|
|
func NewENSRegistryWithFallbackTransactor(address common.Address, transactor bind.ContractTransactor) (*ENSRegistryWithFallbackTransactor, error) {
|
|
contract, err := bindENSRegistryWithFallback(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryWithFallbackTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewENSRegistryWithFallbackFilterer creates a new log filterer instance of ENSRegistryWithFallback, bound to a specific deployed contract.
|
|
func NewENSRegistryWithFallbackFilterer(address common.Address, filterer bind.ContractFilterer) (*ENSRegistryWithFallbackFilterer, error) {
|
|
contract, err := bindENSRegistryWithFallback(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryWithFallbackFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindENSRegistryWithFallback binds a generic wrapper to an already deployed contract.
|
|
func bindENSRegistryWithFallback(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(ENSRegistryWithFallbackABI))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
|
|
}
|
|
|
|
// 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 (_ENSRegistryWithFallback *ENSRegistryWithFallbackRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ENSRegistryWithFallback.Contract.ENSRegistryWithFallbackCaller.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.ENSRegistryWithFallbackTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.ENSRegistryWithFallbackTransactor.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// 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 (_ENSRegistryWithFallback *ENSRegistryWithFallbackCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ENSRegistryWithFallback.Contract.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackCaller) IsApprovedForAll(opts *bind.CallOpts, owner common.Address, operator common.Address) (bool, error) {
|
|
var out []interface{}
|
|
err := _ENSRegistryWithFallback.contract.Call(opts, &out, "isApprovedForAll", owner, operator)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _ENSRegistryWithFallback.Contract.IsApprovedForAll(&_ENSRegistryWithFallback.CallOpts, owner, operator)
|
|
}
|
|
|
|
// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
|
|
//
|
|
// Solidity: function isApprovedForAll(address owner, address operator) view returns(bool)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackCallerSession) IsApprovedForAll(owner common.Address, operator common.Address) (bool, error) {
|
|
return _ENSRegistryWithFallback.Contract.IsApprovedForAll(&_ENSRegistryWithFallback.CallOpts, owner, operator)
|
|
}
|
|
|
|
// Owner is a free data retrieval call binding the contract method 0x02571be3.
|
|
//
|
|
// Solidity: function owner(bytes32 node) view returns(address)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackCaller) Owner(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _ENSRegistryWithFallback.contract.Call(opts, &out, "owner", node)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Owner is a free data retrieval call binding the contract method 0x02571be3.
|
|
//
|
|
// Solidity: function owner(bytes32 node) view returns(address)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackSession) Owner(node [32]byte) (common.Address, error) {
|
|
return _ENSRegistryWithFallback.Contract.Owner(&_ENSRegistryWithFallback.CallOpts, node)
|
|
}
|
|
|
|
// Owner is a free data retrieval call binding the contract method 0x02571be3.
|
|
//
|
|
// Solidity: function owner(bytes32 node) view returns(address)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackCallerSession) Owner(node [32]byte) (common.Address, error) {
|
|
return _ENSRegistryWithFallback.Contract.Owner(&_ENSRegistryWithFallback.CallOpts, node)
|
|
}
|
|
|
|
// RecordExists is a free data retrieval call binding the contract method 0xf79fe538.
|
|
//
|
|
// Solidity: function recordExists(bytes32 node) view returns(bool)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackCaller) RecordExists(opts *bind.CallOpts, node [32]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _ENSRegistryWithFallback.contract.Call(opts, &out, "recordExists", node)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// RecordExists is a free data retrieval call binding the contract method 0xf79fe538.
|
|
//
|
|
// Solidity: function recordExists(bytes32 node) view returns(bool)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackSession) RecordExists(node [32]byte) (bool, error) {
|
|
return _ENSRegistryWithFallback.Contract.RecordExists(&_ENSRegistryWithFallback.CallOpts, node)
|
|
}
|
|
|
|
// RecordExists is a free data retrieval call binding the contract method 0xf79fe538.
|
|
//
|
|
// Solidity: function recordExists(bytes32 node) view returns(bool)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackCallerSession) RecordExists(node [32]byte) (bool, error) {
|
|
return _ENSRegistryWithFallback.Contract.RecordExists(&_ENSRegistryWithFallback.CallOpts, node)
|
|
}
|
|
|
|
// Resolver is a free data retrieval call binding the contract method 0x0178b8bf.
|
|
//
|
|
// Solidity: function resolver(bytes32 node) view returns(address)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackCaller) Resolver(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _ENSRegistryWithFallback.contract.Call(opts, &out, "resolver", node)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Resolver is a free data retrieval call binding the contract method 0x0178b8bf.
|
|
//
|
|
// Solidity: function resolver(bytes32 node) view returns(address)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackSession) Resolver(node [32]byte) (common.Address, error) {
|
|
return _ENSRegistryWithFallback.Contract.Resolver(&_ENSRegistryWithFallback.CallOpts, node)
|
|
}
|
|
|
|
// Resolver is a free data retrieval call binding the contract method 0x0178b8bf.
|
|
//
|
|
// Solidity: function resolver(bytes32 node) view returns(address)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackCallerSession) Resolver(node [32]byte) (common.Address, error) {
|
|
return _ENSRegistryWithFallback.Contract.Resolver(&_ENSRegistryWithFallback.CallOpts, node)
|
|
}
|
|
|
|
// Ttl is a free data retrieval call binding the contract method 0x16a25cbd.
|
|
//
|
|
// Solidity: function ttl(bytes32 node) view returns(uint64)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackCaller) Ttl(opts *bind.CallOpts, node [32]byte) (uint64, error) {
|
|
var out []interface{}
|
|
err := _ENSRegistryWithFallback.contract.Call(opts, &out, "ttl", node)
|
|
|
|
if err != nil {
|
|
return *new(uint64), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(uint64)).(*uint64)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Ttl is a free data retrieval call binding the contract method 0x16a25cbd.
|
|
//
|
|
// Solidity: function ttl(bytes32 node) view returns(uint64)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackSession) Ttl(node [32]byte) (uint64, error) {
|
|
return _ENSRegistryWithFallback.Contract.Ttl(&_ENSRegistryWithFallback.CallOpts, node)
|
|
}
|
|
|
|
// Ttl is a free data retrieval call binding the contract method 0x16a25cbd.
|
|
//
|
|
// Solidity: function ttl(bytes32 node) view returns(uint64)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackCallerSession) Ttl(node [32]byte) (uint64, error) {
|
|
return _ENSRegistryWithFallback.Contract.Ttl(&_ENSRegistryWithFallback.CallOpts, node)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool approved) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactor) SetApprovalForAll(opts *bind.TransactOpts, operator common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.contract.Transact(opts, "setApprovalForAll", operator, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool approved) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.SetApprovalForAll(&_ENSRegistryWithFallback.TransactOpts, operator, approved)
|
|
}
|
|
|
|
// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
|
|
//
|
|
// Solidity: function setApprovalForAll(address operator, bool approved) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactorSession) SetApprovalForAll(operator common.Address, approved bool) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.SetApprovalForAll(&_ENSRegistryWithFallback.TransactOpts, operator, approved)
|
|
}
|
|
|
|
// SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.
|
|
//
|
|
// Solidity: function setOwner(bytes32 node, address owner) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactor) SetOwner(opts *bind.TransactOpts, node [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.contract.Transact(opts, "setOwner", node, owner)
|
|
}
|
|
|
|
// SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.
|
|
//
|
|
// Solidity: function setOwner(bytes32 node, address owner) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackSession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.SetOwner(&_ENSRegistryWithFallback.TransactOpts, node, owner)
|
|
}
|
|
|
|
// SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.
|
|
//
|
|
// Solidity: function setOwner(bytes32 node, address owner) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactorSession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.SetOwner(&_ENSRegistryWithFallback.TransactOpts, node, owner)
|
|
}
|
|
|
|
// SetRecord is a paid mutator transaction binding the contract method 0xcf408823.
|
|
//
|
|
// Solidity: function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactor) SetRecord(opts *bind.TransactOpts, node [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.contract.Transact(opts, "setRecord", node, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetRecord is a paid mutator transaction binding the contract method 0xcf408823.
|
|
//
|
|
// Solidity: function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackSession) SetRecord(node [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.SetRecord(&_ENSRegistryWithFallback.TransactOpts, node, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetRecord is a paid mutator transaction binding the contract method 0xcf408823.
|
|
//
|
|
// Solidity: function setRecord(bytes32 node, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactorSession) SetRecord(node [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.SetRecord(&_ENSRegistryWithFallback.TransactOpts, node, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.
|
|
//
|
|
// Solidity: function setResolver(bytes32 node, address resolver) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactor) SetResolver(opts *bind.TransactOpts, node [32]byte, resolver common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.contract.Transact(opts, "setResolver", node, resolver)
|
|
}
|
|
|
|
// SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.
|
|
//
|
|
// Solidity: function setResolver(bytes32 node, address resolver) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackSession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.SetResolver(&_ENSRegistryWithFallback.TransactOpts, node, resolver)
|
|
}
|
|
|
|
// SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.
|
|
//
|
|
// Solidity: function setResolver(bytes32 node, address resolver) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactorSession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.SetResolver(&_ENSRegistryWithFallback.TransactOpts, node, resolver)
|
|
}
|
|
|
|
// SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923.
|
|
//
|
|
// Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns(bytes32)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactor) SetSubnodeOwner(opts *bind.TransactOpts, node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.contract.Transact(opts, "setSubnodeOwner", node, label, owner)
|
|
}
|
|
|
|
// SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923.
|
|
//
|
|
// Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns(bytes32)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackSession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.SetSubnodeOwner(&_ENSRegistryWithFallback.TransactOpts, node, label, owner)
|
|
}
|
|
|
|
// SetSubnodeOwner is a paid mutator transaction binding the contract method 0x06ab5923.
|
|
//
|
|
// Solidity: function setSubnodeOwner(bytes32 node, bytes32 label, address owner) returns(bytes32)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactorSession) SetSubnodeOwner(node [32]byte, label [32]byte, owner common.Address) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.SetSubnodeOwner(&_ENSRegistryWithFallback.TransactOpts, node, label, owner)
|
|
}
|
|
|
|
// SetSubnodeRecord is a paid mutator transaction binding the contract method 0x5ef2c7f0.
|
|
//
|
|
// Solidity: function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactor) SetSubnodeRecord(opts *bind.TransactOpts, node [32]byte, label [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.contract.Transact(opts, "setSubnodeRecord", node, label, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetSubnodeRecord is a paid mutator transaction binding the contract method 0x5ef2c7f0.
|
|
//
|
|
// Solidity: function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackSession) SetSubnodeRecord(node [32]byte, label [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.SetSubnodeRecord(&_ENSRegistryWithFallback.TransactOpts, node, label, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetSubnodeRecord is a paid mutator transaction binding the contract method 0x5ef2c7f0.
|
|
//
|
|
// Solidity: function setSubnodeRecord(bytes32 node, bytes32 label, address owner, address resolver, uint64 ttl) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactorSession) SetSubnodeRecord(node [32]byte, label [32]byte, owner common.Address, resolver common.Address, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.SetSubnodeRecord(&_ENSRegistryWithFallback.TransactOpts, node, label, owner, resolver, ttl)
|
|
}
|
|
|
|
// SetTTL is a paid mutator transaction binding the contract method 0x14ab9038.
|
|
//
|
|
// Solidity: function setTTL(bytes32 node, uint64 ttl) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactor) SetTTL(opts *bind.TransactOpts, node [32]byte, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.contract.Transact(opts, "setTTL", node, ttl)
|
|
}
|
|
|
|
// SetTTL is a paid mutator transaction binding the contract method 0x14ab9038.
|
|
//
|
|
// Solidity: function setTTL(bytes32 node, uint64 ttl) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackSession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.SetTTL(&_ENSRegistryWithFallback.TransactOpts, node, ttl)
|
|
}
|
|
|
|
// SetTTL is a paid mutator transaction binding the contract method 0x14ab9038.
|
|
//
|
|
// Solidity: function setTTL(bytes32 node, uint64 ttl) returns()
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackTransactorSession) SetTTL(node [32]byte, ttl uint64) (*types.Transaction, error) {
|
|
return _ENSRegistryWithFallback.Contract.SetTTL(&_ENSRegistryWithFallback.TransactOpts, node, ttl)
|
|
}
|
|
|
|
// ENSRegistryWithFallbackApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the ENSRegistryWithFallback contract.
|
|
type ENSRegistryWithFallbackApprovalForAllIterator struct {
|
|
Event *ENSRegistryWithFallbackApprovalForAll // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ENSRegistryWithFallbackApprovalForAllIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryWithFallbackApprovalForAll)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryWithFallbackApprovalForAll)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ENSRegistryWithFallbackApprovalForAllIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ENSRegistryWithFallbackApprovalForAllIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ENSRegistryWithFallbackApprovalForAll represents a ApprovalForAll event raised by the ENSRegistryWithFallback contract.
|
|
type ENSRegistryWithFallbackApprovalForAll struct {
|
|
Owner common.Address
|
|
Operator common.Address
|
|
Approved bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackFilterer) FilterApprovalForAll(opts *bind.FilterOpts, owner []common.Address, operator []common.Address) (*ENSRegistryWithFallbackApprovalForAllIterator, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistryWithFallback.contract.FilterLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryWithFallbackApprovalForAllIterator{contract: _ENSRegistryWithFallback.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackFilterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *ENSRegistryWithFallbackApprovalForAll, owner []common.Address, operator []common.Address) (event.Subscription, error) {
|
|
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var operatorRule []interface{}
|
|
for _, operatorItem := range operator {
|
|
operatorRule = append(operatorRule, operatorItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistryWithFallback.contract.WatchLogs(opts, "ApprovalForAll", ownerRule, operatorRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ENSRegistryWithFallbackApprovalForAll)
|
|
if err := _ENSRegistryWithFallback.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
|
|
//
|
|
// Solidity: event ApprovalForAll(address indexed owner, address indexed operator, bool approved)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackFilterer) ParseApprovalForAll(log types.Log) (*ENSRegistryWithFallbackApprovalForAll, error) {
|
|
event := new(ENSRegistryWithFallbackApprovalForAll)
|
|
if err := _ENSRegistryWithFallback.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ENSRegistryWithFallbackNewOwnerIterator is returned from FilterNewOwner and is used to iterate over the raw logs and unpacked data for NewOwner events raised by the ENSRegistryWithFallback contract.
|
|
type ENSRegistryWithFallbackNewOwnerIterator struct {
|
|
Event *ENSRegistryWithFallbackNewOwner // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ENSRegistryWithFallbackNewOwnerIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryWithFallbackNewOwner)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryWithFallbackNewOwner)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ENSRegistryWithFallbackNewOwnerIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ENSRegistryWithFallbackNewOwnerIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ENSRegistryWithFallbackNewOwner represents a NewOwner event raised by the ENSRegistryWithFallback contract.
|
|
type ENSRegistryWithFallbackNewOwner struct {
|
|
Node [32]byte
|
|
Label [32]byte
|
|
Owner common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterNewOwner is a free log retrieval operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82.
|
|
//
|
|
// Solidity: event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackFilterer) FilterNewOwner(opts *bind.FilterOpts, node [][32]byte, label [][32]byte) (*ENSRegistryWithFallbackNewOwnerIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var labelRule []interface{}
|
|
for _, labelItem := range label {
|
|
labelRule = append(labelRule, labelItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistryWithFallback.contract.FilterLogs(opts, "NewOwner", nodeRule, labelRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryWithFallbackNewOwnerIterator{contract: _ENSRegistryWithFallback.contract, event: "NewOwner", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchNewOwner is a free log subscription operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82.
|
|
//
|
|
// Solidity: event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackFilterer) WatchNewOwner(opts *bind.WatchOpts, sink chan<- *ENSRegistryWithFallbackNewOwner, node [][32]byte, label [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var labelRule []interface{}
|
|
for _, labelItem := range label {
|
|
labelRule = append(labelRule, labelItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistryWithFallback.contract.WatchLogs(opts, "NewOwner", nodeRule, labelRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ENSRegistryWithFallbackNewOwner)
|
|
if err := _ENSRegistryWithFallback.contract.UnpackLog(event, "NewOwner", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseNewOwner is a log parse operation binding the contract event 0xce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e82.
|
|
//
|
|
// Solidity: event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackFilterer) ParseNewOwner(log types.Log) (*ENSRegistryWithFallbackNewOwner, error) {
|
|
event := new(ENSRegistryWithFallbackNewOwner)
|
|
if err := _ENSRegistryWithFallback.contract.UnpackLog(event, "NewOwner", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ENSRegistryWithFallbackNewResolverIterator is returned from FilterNewResolver and is used to iterate over the raw logs and unpacked data for NewResolver events raised by the ENSRegistryWithFallback contract.
|
|
type ENSRegistryWithFallbackNewResolverIterator struct {
|
|
Event *ENSRegistryWithFallbackNewResolver // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ENSRegistryWithFallbackNewResolverIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryWithFallbackNewResolver)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryWithFallbackNewResolver)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ENSRegistryWithFallbackNewResolverIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ENSRegistryWithFallbackNewResolverIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ENSRegistryWithFallbackNewResolver represents a NewResolver event raised by the ENSRegistryWithFallback contract.
|
|
type ENSRegistryWithFallbackNewResolver struct {
|
|
Node [32]byte
|
|
Resolver common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterNewResolver is a free log retrieval operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0.
|
|
//
|
|
// Solidity: event NewResolver(bytes32 indexed node, address resolver)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackFilterer) FilterNewResolver(opts *bind.FilterOpts, node [][32]byte) (*ENSRegistryWithFallbackNewResolverIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistryWithFallback.contract.FilterLogs(opts, "NewResolver", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryWithFallbackNewResolverIterator{contract: _ENSRegistryWithFallback.contract, event: "NewResolver", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchNewResolver is a free log subscription operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0.
|
|
//
|
|
// Solidity: event NewResolver(bytes32 indexed node, address resolver)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackFilterer) WatchNewResolver(opts *bind.WatchOpts, sink chan<- *ENSRegistryWithFallbackNewResolver, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistryWithFallback.contract.WatchLogs(opts, "NewResolver", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ENSRegistryWithFallbackNewResolver)
|
|
if err := _ENSRegistryWithFallback.contract.UnpackLog(event, "NewResolver", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseNewResolver is a log parse operation binding the contract event 0x335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a0.
|
|
//
|
|
// Solidity: event NewResolver(bytes32 indexed node, address resolver)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackFilterer) ParseNewResolver(log types.Log) (*ENSRegistryWithFallbackNewResolver, error) {
|
|
event := new(ENSRegistryWithFallbackNewResolver)
|
|
if err := _ENSRegistryWithFallback.contract.UnpackLog(event, "NewResolver", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ENSRegistryWithFallbackNewTTLIterator is returned from FilterNewTTL and is used to iterate over the raw logs and unpacked data for NewTTL events raised by the ENSRegistryWithFallback contract.
|
|
type ENSRegistryWithFallbackNewTTLIterator struct {
|
|
Event *ENSRegistryWithFallbackNewTTL // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ENSRegistryWithFallbackNewTTLIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryWithFallbackNewTTL)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryWithFallbackNewTTL)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ENSRegistryWithFallbackNewTTLIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ENSRegistryWithFallbackNewTTLIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ENSRegistryWithFallbackNewTTL represents a NewTTL event raised by the ENSRegistryWithFallback contract.
|
|
type ENSRegistryWithFallbackNewTTL struct {
|
|
Node [32]byte
|
|
Ttl uint64
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterNewTTL is a free log retrieval operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68.
|
|
//
|
|
// Solidity: event NewTTL(bytes32 indexed node, uint64 ttl)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackFilterer) FilterNewTTL(opts *bind.FilterOpts, node [][32]byte) (*ENSRegistryWithFallbackNewTTLIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistryWithFallback.contract.FilterLogs(opts, "NewTTL", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryWithFallbackNewTTLIterator{contract: _ENSRegistryWithFallback.contract, event: "NewTTL", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchNewTTL is a free log subscription operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68.
|
|
//
|
|
// Solidity: event NewTTL(bytes32 indexed node, uint64 ttl)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackFilterer) WatchNewTTL(opts *bind.WatchOpts, sink chan<- *ENSRegistryWithFallbackNewTTL, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistryWithFallback.contract.WatchLogs(opts, "NewTTL", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ENSRegistryWithFallbackNewTTL)
|
|
if err := _ENSRegistryWithFallback.contract.UnpackLog(event, "NewTTL", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseNewTTL is a log parse operation binding the contract event 0x1d4f9bbfc9cab89d66e1a1562f2233ccbf1308cb4f63de2ead5787adddb8fa68.
|
|
//
|
|
// Solidity: event NewTTL(bytes32 indexed node, uint64 ttl)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackFilterer) ParseNewTTL(log types.Log) (*ENSRegistryWithFallbackNewTTL, error) {
|
|
event := new(ENSRegistryWithFallbackNewTTL)
|
|
if err := _ENSRegistryWithFallback.contract.UnpackLog(event, "NewTTL", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ENSRegistryWithFallbackTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ENSRegistryWithFallback contract.
|
|
type ENSRegistryWithFallbackTransferIterator struct {
|
|
Event *ENSRegistryWithFallbackTransfer // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *ENSRegistryWithFallbackTransferIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryWithFallbackTransfer)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(ENSRegistryWithFallbackTransfer)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *ENSRegistryWithFallbackTransferIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *ENSRegistryWithFallbackTransferIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// ENSRegistryWithFallbackTransfer represents a Transfer event raised by the ENSRegistryWithFallback contract.
|
|
type ENSRegistryWithFallbackTransfer struct {
|
|
Node [32]byte
|
|
Owner common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterTransfer is a free log retrieval operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266.
|
|
//
|
|
// Solidity: event Transfer(bytes32 indexed node, address owner)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackFilterer) FilterTransfer(opts *bind.FilterOpts, node [][32]byte) (*ENSRegistryWithFallbackTransferIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistryWithFallback.contract.FilterLogs(opts, "Transfer", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ENSRegistryWithFallbackTransferIterator{contract: _ENSRegistryWithFallback.contract, event: "Transfer", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchTransfer is a free log subscription operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266.
|
|
//
|
|
// Solidity: event Transfer(bytes32 indexed node, address owner)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ENSRegistryWithFallbackTransfer, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _ENSRegistryWithFallback.contract.WatchLogs(opts, "Transfer", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(ENSRegistryWithFallbackTransfer)
|
|
if err := _ENSRegistryWithFallback.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseTransfer is a log parse operation binding the contract event 0xd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d266.
|
|
//
|
|
// Solidity: event Transfer(bytes32 indexed node, address owner)
|
|
func (_ENSRegistryWithFallback *ENSRegistryWithFallbackFilterer) ParseTransfer(log types.Log) (*ENSRegistryWithFallbackTransfer, error) {
|
|
event := new(ENSRegistryWithFallbackTransfer)
|
|
if err := _ENSRegistryWithFallback.contract.UnpackLog(event, "Transfer", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// InterfaceResolverABI is the input ABI used to generate the binding from.
|
|
const InterfaceResolverABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"interfaceImplementer\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"addr\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"coinType\",\"type\":\"uint256\"},{\"name\":\"a\",\"type\":\"bytes\"}],\"name\":\"setAddr\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"a\",\"type\":\"address\"}],\"name\":\"setAddr\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"interfaceID\",\"type\":\"bytes4\"},{\"name\":\"implementer\",\"type\":\"address\"}],\"name\":\"setInterface\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"coinType\",\"type\":\"uint256\"}],\"name\":\"addr\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"interfaceID\",\"type\":\"bytes4\"},{\"indexed\":false,\"name\":\"implementer\",\"type\":\"address\"}],\"name\":\"InterfaceChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"a\",\"type\":\"address\"}],\"name\":\"AddrChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"coinType\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"newAddress\",\"type\":\"bytes\"}],\"name\":\"AddressChanged\",\"type\":\"event\"}]"
|
|
|
|
// InterfaceResolverFuncSigs maps the 4-byte function signature to its string representation.
|
|
var InterfaceResolverFuncSigs = map[string]string{
|
|
"3b3b57de": "addr(bytes32)",
|
|
"f1cb7e06": "addr(bytes32,uint256)",
|
|
"124a319c": "interfaceImplementer(bytes32,bytes4)",
|
|
"d5fa2b00": "setAddr(bytes32,address)",
|
|
"8b95dd71": "setAddr(bytes32,uint256,bytes)",
|
|
"e59d895d": "setInterface(bytes32,bytes4,address)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
}
|
|
|
|
// InterfaceResolver is an auto generated Go binding around an Ethereum contract.
|
|
type InterfaceResolver struct {
|
|
InterfaceResolverCaller // Read-only binding to the contract
|
|
InterfaceResolverTransactor // Write-only binding to the contract
|
|
InterfaceResolverFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// InterfaceResolverCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type InterfaceResolverCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// InterfaceResolverTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type InterfaceResolverTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// InterfaceResolverFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type InterfaceResolverFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// InterfaceResolverSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type InterfaceResolverSession struct {
|
|
Contract *InterfaceResolver // 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
|
|
}
|
|
|
|
// InterfaceResolverCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type InterfaceResolverCallerSession struct {
|
|
Contract *InterfaceResolverCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// InterfaceResolverTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type InterfaceResolverTransactorSession struct {
|
|
Contract *InterfaceResolverTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// InterfaceResolverRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type InterfaceResolverRaw struct {
|
|
Contract *InterfaceResolver // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// InterfaceResolverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type InterfaceResolverCallerRaw struct {
|
|
Contract *InterfaceResolverCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// InterfaceResolverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type InterfaceResolverTransactorRaw struct {
|
|
Contract *InterfaceResolverTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewInterfaceResolver creates a new instance of InterfaceResolver, bound to a specific deployed contract.
|
|
func NewInterfaceResolver(address common.Address, backend bind.ContractBackend) (*InterfaceResolver, error) {
|
|
contract, err := bindInterfaceResolver(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &InterfaceResolver{InterfaceResolverCaller: InterfaceResolverCaller{contract: contract}, InterfaceResolverTransactor: InterfaceResolverTransactor{contract: contract}, InterfaceResolverFilterer: InterfaceResolverFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewInterfaceResolverCaller creates a new read-only instance of InterfaceResolver, bound to a specific deployed contract.
|
|
func NewInterfaceResolverCaller(address common.Address, caller bind.ContractCaller) (*InterfaceResolverCaller, error) {
|
|
contract, err := bindInterfaceResolver(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &InterfaceResolverCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewInterfaceResolverTransactor creates a new write-only instance of InterfaceResolver, bound to a specific deployed contract.
|
|
func NewInterfaceResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*InterfaceResolverTransactor, error) {
|
|
contract, err := bindInterfaceResolver(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &InterfaceResolverTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewInterfaceResolverFilterer creates a new log filterer instance of InterfaceResolver, bound to a specific deployed contract.
|
|
func NewInterfaceResolverFilterer(address common.Address, filterer bind.ContractFilterer) (*InterfaceResolverFilterer, error) {
|
|
contract, err := bindInterfaceResolver(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &InterfaceResolverFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindInterfaceResolver binds a generic wrapper to an already deployed contract.
|
|
func bindInterfaceResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(InterfaceResolverABI))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
|
|
}
|
|
|
|
// 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 (_InterfaceResolver *InterfaceResolverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _InterfaceResolver.Contract.InterfaceResolverCaller.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_InterfaceResolver *InterfaceResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _InterfaceResolver.Contract.InterfaceResolverTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_InterfaceResolver *InterfaceResolverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _InterfaceResolver.Contract.InterfaceResolverTransactor.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// 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 (_InterfaceResolver *InterfaceResolverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _InterfaceResolver.Contract.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_InterfaceResolver *InterfaceResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _InterfaceResolver.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_InterfaceResolver *InterfaceResolverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _InterfaceResolver.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
|
|
//
|
|
// Solidity: function addr(bytes32 node) view returns(address)
|
|
func (_InterfaceResolver *InterfaceResolverCaller) Addr(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _InterfaceResolver.contract.Call(opts, &out, "addr", node)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
|
|
//
|
|
// Solidity: function addr(bytes32 node) view returns(address)
|
|
func (_InterfaceResolver *InterfaceResolverSession) Addr(node [32]byte) (common.Address, error) {
|
|
return _InterfaceResolver.Contract.Addr(&_InterfaceResolver.CallOpts, node)
|
|
}
|
|
|
|
// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
|
|
//
|
|
// Solidity: function addr(bytes32 node) view returns(address)
|
|
func (_InterfaceResolver *InterfaceResolverCallerSession) Addr(node [32]byte) (common.Address, error) {
|
|
return _InterfaceResolver.Contract.Addr(&_InterfaceResolver.CallOpts, node)
|
|
}
|
|
|
|
// Addr0 is a free data retrieval call binding the contract method 0xf1cb7e06.
|
|
//
|
|
// Solidity: function addr(bytes32 node, uint256 coinType) view returns(bytes)
|
|
func (_InterfaceResolver *InterfaceResolverCaller) Addr0(opts *bind.CallOpts, node [32]byte, coinType *big.Int) ([]byte, error) {
|
|
var out []interface{}
|
|
err := _InterfaceResolver.contract.Call(opts, &out, "addr0", node, coinType)
|
|
|
|
if err != nil {
|
|
return *new([]byte), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Addr0 is a free data retrieval call binding the contract method 0xf1cb7e06.
|
|
//
|
|
// Solidity: function addr(bytes32 node, uint256 coinType) view returns(bytes)
|
|
func (_InterfaceResolver *InterfaceResolverSession) Addr0(node [32]byte, coinType *big.Int) ([]byte, error) {
|
|
return _InterfaceResolver.Contract.Addr0(&_InterfaceResolver.CallOpts, node, coinType)
|
|
}
|
|
|
|
// Addr0 is a free data retrieval call binding the contract method 0xf1cb7e06.
|
|
//
|
|
// Solidity: function addr(bytes32 node, uint256 coinType) view returns(bytes)
|
|
func (_InterfaceResolver *InterfaceResolverCallerSession) Addr0(node [32]byte, coinType *big.Int) ([]byte, error) {
|
|
return _InterfaceResolver.Contract.Addr0(&_InterfaceResolver.CallOpts, node, coinType)
|
|
}
|
|
|
|
// InterfaceImplementer is a free data retrieval call binding the contract method 0x124a319c.
|
|
//
|
|
// Solidity: function interfaceImplementer(bytes32 node, bytes4 interfaceID) view returns(address)
|
|
func (_InterfaceResolver *InterfaceResolverCaller) InterfaceImplementer(opts *bind.CallOpts, node [32]byte, interfaceID [4]byte) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _InterfaceResolver.contract.Call(opts, &out, "interfaceImplementer", node, interfaceID)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// InterfaceImplementer is a free data retrieval call binding the contract method 0x124a319c.
|
|
//
|
|
// Solidity: function interfaceImplementer(bytes32 node, bytes4 interfaceID) view returns(address)
|
|
func (_InterfaceResolver *InterfaceResolverSession) InterfaceImplementer(node [32]byte, interfaceID [4]byte) (common.Address, error) {
|
|
return _InterfaceResolver.Contract.InterfaceImplementer(&_InterfaceResolver.CallOpts, node, interfaceID)
|
|
}
|
|
|
|
// InterfaceImplementer is a free data retrieval call binding the contract method 0x124a319c.
|
|
//
|
|
// Solidity: function interfaceImplementer(bytes32 node, bytes4 interfaceID) view returns(address)
|
|
func (_InterfaceResolver *InterfaceResolverCallerSession) InterfaceImplementer(node [32]byte, interfaceID [4]byte) (common.Address, error) {
|
|
return _InterfaceResolver.Contract.InterfaceImplementer(&_InterfaceResolver.CallOpts, node, interfaceID)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_InterfaceResolver *InterfaceResolverCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _InterfaceResolver.contract.Call(opts, &out, "supportsInterface", interfaceID)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_InterfaceResolver *InterfaceResolverSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _InterfaceResolver.Contract.SupportsInterface(&_InterfaceResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_InterfaceResolver *InterfaceResolverCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _InterfaceResolver.Contract.SupportsInterface(&_InterfaceResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SetAddr is a paid mutator transaction binding the contract method 0x8b95dd71.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, uint256 coinType, bytes a) returns()
|
|
func (_InterfaceResolver *InterfaceResolverTransactor) SetAddr(opts *bind.TransactOpts, node [32]byte, coinType *big.Int, a []byte) (*types.Transaction, error) {
|
|
return _InterfaceResolver.contract.Transact(opts, "setAddr", node, coinType, a)
|
|
}
|
|
|
|
// SetAddr is a paid mutator transaction binding the contract method 0x8b95dd71.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, uint256 coinType, bytes a) returns()
|
|
func (_InterfaceResolver *InterfaceResolverSession) SetAddr(node [32]byte, coinType *big.Int, a []byte) (*types.Transaction, error) {
|
|
return _InterfaceResolver.Contract.SetAddr(&_InterfaceResolver.TransactOpts, node, coinType, a)
|
|
}
|
|
|
|
// SetAddr is a paid mutator transaction binding the contract method 0x8b95dd71.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, uint256 coinType, bytes a) returns()
|
|
func (_InterfaceResolver *InterfaceResolverTransactorSession) SetAddr(node [32]byte, coinType *big.Int, a []byte) (*types.Transaction, error) {
|
|
return _InterfaceResolver.Contract.SetAddr(&_InterfaceResolver.TransactOpts, node, coinType, a)
|
|
}
|
|
|
|
// SetAddr0 is a paid mutator transaction binding the contract method 0xd5fa2b00.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, address a) returns()
|
|
func (_InterfaceResolver *InterfaceResolverTransactor) SetAddr0(opts *bind.TransactOpts, node [32]byte, a common.Address) (*types.Transaction, error) {
|
|
return _InterfaceResolver.contract.Transact(opts, "setAddr0", node, a)
|
|
}
|
|
|
|
// SetAddr0 is a paid mutator transaction binding the contract method 0xd5fa2b00.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, address a) returns()
|
|
func (_InterfaceResolver *InterfaceResolverSession) SetAddr0(node [32]byte, a common.Address) (*types.Transaction, error) {
|
|
return _InterfaceResolver.Contract.SetAddr0(&_InterfaceResolver.TransactOpts, node, a)
|
|
}
|
|
|
|
// SetAddr0 is a paid mutator transaction binding the contract method 0xd5fa2b00.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, address a) returns()
|
|
func (_InterfaceResolver *InterfaceResolverTransactorSession) SetAddr0(node [32]byte, a common.Address) (*types.Transaction, error) {
|
|
return _InterfaceResolver.Contract.SetAddr0(&_InterfaceResolver.TransactOpts, node, a)
|
|
}
|
|
|
|
// SetInterface is a paid mutator transaction binding the contract method 0xe59d895d.
|
|
//
|
|
// Solidity: function setInterface(bytes32 node, bytes4 interfaceID, address implementer) returns()
|
|
func (_InterfaceResolver *InterfaceResolverTransactor) SetInterface(opts *bind.TransactOpts, node [32]byte, interfaceID [4]byte, implementer common.Address) (*types.Transaction, error) {
|
|
return _InterfaceResolver.contract.Transact(opts, "setInterface", node, interfaceID, implementer)
|
|
}
|
|
|
|
// SetInterface is a paid mutator transaction binding the contract method 0xe59d895d.
|
|
//
|
|
// Solidity: function setInterface(bytes32 node, bytes4 interfaceID, address implementer) returns()
|
|
func (_InterfaceResolver *InterfaceResolverSession) SetInterface(node [32]byte, interfaceID [4]byte, implementer common.Address) (*types.Transaction, error) {
|
|
return _InterfaceResolver.Contract.SetInterface(&_InterfaceResolver.TransactOpts, node, interfaceID, implementer)
|
|
}
|
|
|
|
// SetInterface is a paid mutator transaction binding the contract method 0xe59d895d.
|
|
//
|
|
// Solidity: function setInterface(bytes32 node, bytes4 interfaceID, address implementer) returns()
|
|
func (_InterfaceResolver *InterfaceResolverTransactorSession) SetInterface(node [32]byte, interfaceID [4]byte, implementer common.Address) (*types.Transaction, error) {
|
|
return _InterfaceResolver.Contract.SetInterface(&_InterfaceResolver.TransactOpts, node, interfaceID, implementer)
|
|
}
|
|
|
|
// InterfaceResolverAddrChangedIterator is returned from FilterAddrChanged and is used to iterate over the raw logs and unpacked data for AddrChanged events raised by the InterfaceResolver contract.
|
|
type InterfaceResolverAddrChangedIterator struct {
|
|
Event *InterfaceResolverAddrChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *InterfaceResolverAddrChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(InterfaceResolverAddrChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(InterfaceResolverAddrChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *InterfaceResolverAddrChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *InterfaceResolverAddrChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// InterfaceResolverAddrChanged represents a AddrChanged event raised by the InterfaceResolver contract.
|
|
type InterfaceResolverAddrChanged struct {
|
|
Node [32]byte
|
|
A common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterAddrChanged is a free log retrieval operation binding the contract event 0x52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2.
|
|
//
|
|
// Solidity: event AddrChanged(bytes32 indexed node, address a)
|
|
func (_InterfaceResolver *InterfaceResolverFilterer) FilterAddrChanged(opts *bind.FilterOpts, node [][32]byte) (*InterfaceResolverAddrChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _InterfaceResolver.contract.FilterLogs(opts, "AddrChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &InterfaceResolverAddrChangedIterator{contract: _InterfaceResolver.contract, event: "AddrChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchAddrChanged is a free log subscription operation binding the contract event 0x52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2.
|
|
//
|
|
// Solidity: event AddrChanged(bytes32 indexed node, address a)
|
|
func (_InterfaceResolver *InterfaceResolverFilterer) WatchAddrChanged(opts *bind.WatchOpts, sink chan<- *InterfaceResolverAddrChanged, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _InterfaceResolver.contract.WatchLogs(opts, "AddrChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(InterfaceResolverAddrChanged)
|
|
if err := _InterfaceResolver.contract.UnpackLog(event, "AddrChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseAddrChanged is a log parse operation binding the contract event 0x52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2.
|
|
//
|
|
// Solidity: event AddrChanged(bytes32 indexed node, address a)
|
|
func (_InterfaceResolver *InterfaceResolverFilterer) ParseAddrChanged(log types.Log) (*InterfaceResolverAddrChanged, error) {
|
|
event := new(InterfaceResolverAddrChanged)
|
|
if err := _InterfaceResolver.contract.UnpackLog(event, "AddrChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// InterfaceResolverAddressChangedIterator is returned from FilterAddressChanged and is used to iterate over the raw logs and unpacked data for AddressChanged events raised by the InterfaceResolver contract.
|
|
type InterfaceResolverAddressChangedIterator struct {
|
|
Event *InterfaceResolverAddressChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *InterfaceResolverAddressChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(InterfaceResolverAddressChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(InterfaceResolverAddressChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *InterfaceResolverAddressChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *InterfaceResolverAddressChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// InterfaceResolverAddressChanged represents a AddressChanged event raised by the InterfaceResolver contract.
|
|
type InterfaceResolverAddressChanged struct {
|
|
Node [32]byte
|
|
CoinType *big.Int
|
|
NewAddress []byte
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterAddressChanged is a free log retrieval operation binding the contract event 0x65412581168e88a1e60c6459d7f44ae83ad0832e670826c05a4e2476b57af752.
|
|
//
|
|
// Solidity: event AddressChanged(bytes32 indexed node, uint256 coinType, bytes newAddress)
|
|
func (_InterfaceResolver *InterfaceResolverFilterer) FilterAddressChanged(opts *bind.FilterOpts, node [][32]byte) (*InterfaceResolverAddressChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _InterfaceResolver.contract.FilterLogs(opts, "AddressChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &InterfaceResolverAddressChangedIterator{contract: _InterfaceResolver.contract, event: "AddressChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchAddressChanged is a free log subscription operation binding the contract event 0x65412581168e88a1e60c6459d7f44ae83ad0832e670826c05a4e2476b57af752.
|
|
//
|
|
// Solidity: event AddressChanged(bytes32 indexed node, uint256 coinType, bytes newAddress)
|
|
func (_InterfaceResolver *InterfaceResolverFilterer) WatchAddressChanged(opts *bind.WatchOpts, sink chan<- *InterfaceResolverAddressChanged, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _InterfaceResolver.contract.WatchLogs(opts, "AddressChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(InterfaceResolverAddressChanged)
|
|
if err := _InterfaceResolver.contract.UnpackLog(event, "AddressChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseAddressChanged is a log parse operation binding the contract event 0x65412581168e88a1e60c6459d7f44ae83ad0832e670826c05a4e2476b57af752.
|
|
//
|
|
// Solidity: event AddressChanged(bytes32 indexed node, uint256 coinType, bytes newAddress)
|
|
func (_InterfaceResolver *InterfaceResolverFilterer) ParseAddressChanged(log types.Log) (*InterfaceResolverAddressChanged, error) {
|
|
event := new(InterfaceResolverAddressChanged)
|
|
if err := _InterfaceResolver.contract.UnpackLog(event, "AddressChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// InterfaceResolverInterfaceChangedIterator is returned from FilterInterfaceChanged and is used to iterate over the raw logs and unpacked data for InterfaceChanged events raised by the InterfaceResolver contract.
|
|
type InterfaceResolverInterfaceChangedIterator struct {
|
|
Event *InterfaceResolverInterfaceChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *InterfaceResolverInterfaceChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(InterfaceResolverInterfaceChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(InterfaceResolverInterfaceChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *InterfaceResolverInterfaceChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *InterfaceResolverInterfaceChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// InterfaceResolverInterfaceChanged represents a InterfaceChanged event raised by the InterfaceResolver contract.
|
|
type InterfaceResolverInterfaceChanged struct {
|
|
Node [32]byte
|
|
InterfaceID [4]byte
|
|
Implementer common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterInterfaceChanged is a free log retrieval operation binding the contract event 0x7c69f06bea0bdef565b709e93a147836b0063ba2dd89f02d0b7e8d931e6a6daa.
|
|
//
|
|
// Solidity: event InterfaceChanged(bytes32 indexed node, bytes4 indexed interfaceID, address implementer)
|
|
func (_InterfaceResolver *InterfaceResolverFilterer) FilterInterfaceChanged(opts *bind.FilterOpts, node [][32]byte, interfaceID [][4]byte) (*InterfaceResolverInterfaceChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var interfaceIDRule []interface{}
|
|
for _, interfaceIDItem := range interfaceID {
|
|
interfaceIDRule = append(interfaceIDRule, interfaceIDItem)
|
|
}
|
|
|
|
logs, sub, err := _InterfaceResolver.contract.FilterLogs(opts, "InterfaceChanged", nodeRule, interfaceIDRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &InterfaceResolverInterfaceChangedIterator{contract: _InterfaceResolver.contract, event: "InterfaceChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchInterfaceChanged is a free log subscription operation binding the contract event 0x7c69f06bea0bdef565b709e93a147836b0063ba2dd89f02d0b7e8d931e6a6daa.
|
|
//
|
|
// Solidity: event InterfaceChanged(bytes32 indexed node, bytes4 indexed interfaceID, address implementer)
|
|
func (_InterfaceResolver *InterfaceResolverFilterer) WatchInterfaceChanged(opts *bind.WatchOpts, sink chan<- *InterfaceResolverInterfaceChanged, node [][32]byte, interfaceID [][4]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var interfaceIDRule []interface{}
|
|
for _, interfaceIDItem := range interfaceID {
|
|
interfaceIDRule = append(interfaceIDRule, interfaceIDItem)
|
|
}
|
|
|
|
logs, sub, err := _InterfaceResolver.contract.WatchLogs(opts, "InterfaceChanged", nodeRule, interfaceIDRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(InterfaceResolverInterfaceChanged)
|
|
if err := _InterfaceResolver.contract.UnpackLog(event, "InterfaceChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseInterfaceChanged is a log parse operation binding the contract event 0x7c69f06bea0bdef565b709e93a147836b0063ba2dd89f02d0b7e8d931e6a6daa.
|
|
//
|
|
// Solidity: event InterfaceChanged(bytes32 indexed node, bytes4 indexed interfaceID, address implementer)
|
|
func (_InterfaceResolver *InterfaceResolverFilterer) ParseInterfaceChanged(log types.Log) (*InterfaceResolverInterfaceChanged, error) {
|
|
event := new(InterfaceResolverInterfaceChanged)
|
|
if err := _InterfaceResolver.contract.UnpackLog(event, "InterfaceChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// NameResolverABI is the input ABI used to generate the binding from.
|
|
const NameResolverABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"name\",\"type\":\"string\"}],\"name\":\"setName\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"name\",\"type\":\"string\"}],\"name\":\"NameChanged\",\"type\":\"event\"}]"
|
|
|
|
// NameResolverFuncSigs maps the 4-byte function signature to its string representation.
|
|
var NameResolverFuncSigs = map[string]string{
|
|
"691f3431": "name(bytes32)",
|
|
"77372213": "setName(bytes32,string)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
}
|
|
|
|
// NameResolver is an auto generated Go binding around an Ethereum contract.
|
|
type NameResolver struct {
|
|
NameResolverCaller // Read-only binding to the contract
|
|
NameResolverTransactor // Write-only binding to the contract
|
|
NameResolverFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// NameResolverCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type NameResolverCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// NameResolverTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type NameResolverTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// NameResolverFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type NameResolverFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// NameResolverSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type NameResolverSession struct {
|
|
Contract *NameResolver // 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
|
|
}
|
|
|
|
// NameResolverCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type NameResolverCallerSession struct {
|
|
Contract *NameResolverCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// NameResolverTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type NameResolverTransactorSession struct {
|
|
Contract *NameResolverTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// NameResolverRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type NameResolverRaw struct {
|
|
Contract *NameResolver // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// NameResolverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type NameResolverCallerRaw struct {
|
|
Contract *NameResolverCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NameResolverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type NameResolverTransactorRaw struct {
|
|
Contract *NameResolverTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewNameResolver creates a new instance of NameResolver, bound to a specific deployed contract.
|
|
func NewNameResolver(address common.Address, backend bind.ContractBackend) (*NameResolver, error) {
|
|
contract, err := bindNameResolver(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &NameResolver{NameResolverCaller: NameResolverCaller{contract: contract}, NameResolverTransactor: NameResolverTransactor{contract: contract}, NameResolverFilterer: NameResolverFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewNameResolverCaller creates a new read-only instance of NameResolver, bound to a specific deployed contract.
|
|
func NewNameResolverCaller(address common.Address, caller bind.ContractCaller) (*NameResolverCaller, error) {
|
|
contract, err := bindNameResolver(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &NameResolverCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewNameResolverTransactor creates a new write-only instance of NameResolver, bound to a specific deployed contract.
|
|
func NewNameResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*NameResolverTransactor, error) {
|
|
contract, err := bindNameResolver(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &NameResolverTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewNameResolverFilterer creates a new log filterer instance of NameResolver, bound to a specific deployed contract.
|
|
func NewNameResolverFilterer(address common.Address, filterer bind.ContractFilterer) (*NameResolverFilterer, error) {
|
|
contract, err := bindNameResolver(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &NameResolverFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindNameResolver binds a generic wrapper to an already deployed contract.
|
|
func bindNameResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(NameResolverABI))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
|
|
}
|
|
|
|
// 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 (_NameResolver *NameResolverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _NameResolver.Contract.NameResolverCaller.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_NameResolver *NameResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _NameResolver.Contract.NameResolverTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_NameResolver *NameResolverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _NameResolver.Contract.NameResolverTransactor.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// 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 (_NameResolver *NameResolverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _NameResolver.Contract.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_NameResolver *NameResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _NameResolver.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_NameResolver *NameResolverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _NameResolver.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x691f3431.
|
|
//
|
|
// Solidity: function name(bytes32 node) view returns(string)
|
|
func (_NameResolver *NameResolverCaller) Name(opts *bind.CallOpts, node [32]byte) (string, error) {
|
|
var out []interface{}
|
|
err := _NameResolver.contract.Call(opts, &out, "name", node)
|
|
|
|
if err != nil {
|
|
return *new(string), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(string)).(*string)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x691f3431.
|
|
//
|
|
// Solidity: function name(bytes32 node) view returns(string)
|
|
func (_NameResolver *NameResolverSession) Name(node [32]byte) (string, error) {
|
|
return _NameResolver.Contract.Name(&_NameResolver.CallOpts, node)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x691f3431.
|
|
//
|
|
// Solidity: function name(bytes32 node) view returns(string)
|
|
func (_NameResolver *NameResolverCallerSession) Name(node [32]byte) (string, error) {
|
|
return _NameResolver.Contract.Name(&_NameResolver.CallOpts, node)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_NameResolver *NameResolverCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _NameResolver.contract.Call(opts, &out, "supportsInterface", interfaceID)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_NameResolver *NameResolverSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _NameResolver.Contract.SupportsInterface(&_NameResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_NameResolver *NameResolverCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _NameResolver.Contract.SupportsInterface(&_NameResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SetName is a paid mutator transaction binding the contract method 0x77372213.
|
|
//
|
|
// Solidity: function setName(bytes32 node, string name) returns()
|
|
func (_NameResolver *NameResolverTransactor) SetName(opts *bind.TransactOpts, node [32]byte, name string) (*types.Transaction, error) {
|
|
return _NameResolver.contract.Transact(opts, "setName", node, name)
|
|
}
|
|
|
|
// SetName is a paid mutator transaction binding the contract method 0x77372213.
|
|
//
|
|
// Solidity: function setName(bytes32 node, string name) returns()
|
|
func (_NameResolver *NameResolverSession) SetName(node [32]byte, name string) (*types.Transaction, error) {
|
|
return _NameResolver.Contract.SetName(&_NameResolver.TransactOpts, node, name)
|
|
}
|
|
|
|
// SetName is a paid mutator transaction binding the contract method 0x77372213.
|
|
//
|
|
// Solidity: function setName(bytes32 node, string name) returns()
|
|
func (_NameResolver *NameResolverTransactorSession) SetName(node [32]byte, name string) (*types.Transaction, error) {
|
|
return _NameResolver.Contract.SetName(&_NameResolver.TransactOpts, node, name)
|
|
}
|
|
|
|
// NameResolverNameChangedIterator is returned from FilterNameChanged and is used to iterate over the raw logs and unpacked data for NameChanged events raised by the NameResolver contract.
|
|
type NameResolverNameChangedIterator struct {
|
|
Event *NameResolverNameChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *NameResolverNameChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(NameResolverNameChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(NameResolverNameChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *NameResolverNameChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *NameResolverNameChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// NameResolverNameChanged represents a NameChanged event raised by the NameResolver contract.
|
|
type NameResolverNameChanged struct {
|
|
Node [32]byte
|
|
Name string
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterNameChanged is a free log retrieval operation binding the contract event 0xb7d29e911041e8d9b843369e890bcb72c9388692ba48b65ac54e7214c4c348f7.
|
|
//
|
|
// Solidity: event NameChanged(bytes32 indexed node, string name)
|
|
func (_NameResolver *NameResolverFilterer) FilterNameChanged(opts *bind.FilterOpts, node [][32]byte) (*NameResolverNameChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _NameResolver.contract.FilterLogs(opts, "NameChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &NameResolverNameChangedIterator{contract: _NameResolver.contract, event: "NameChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchNameChanged is a free log subscription operation binding the contract event 0xb7d29e911041e8d9b843369e890bcb72c9388692ba48b65ac54e7214c4c348f7.
|
|
//
|
|
// Solidity: event NameChanged(bytes32 indexed node, string name)
|
|
func (_NameResolver *NameResolverFilterer) WatchNameChanged(opts *bind.WatchOpts, sink chan<- *NameResolverNameChanged, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _NameResolver.contract.WatchLogs(opts, "NameChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(NameResolverNameChanged)
|
|
if err := _NameResolver.contract.UnpackLog(event, "NameChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseNameChanged is a log parse operation binding the contract event 0xb7d29e911041e8d9b843369e890bcb72c9388692ba48b65ac54e7214c4c348f7.
|
|
//
|
|
// Solidity: event NameChanged(bytes32 indexed node, string name)
|
|
func (_NameResolver *NameResolverFilterer) ParseNameChanged(log types.Log) (*NameResolverNameChanged, error) {
|
|
event := new(NameResolverNameChanged)
|
|
if err := _NameResolver.contract.UnpackLog(event, "NameChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// PubkeyResolverABI is the input ABI used to generate the binding from.
|
|
const PubkeyResolverABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"x\",\"type\":\"bytes32\"},{\"name\":\"y\",\"type\":\"bytes32\"}],\"name\":\"setPubkey\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"pubkey\",\"outputs\":[{\"name\":\"x\",\"type\":\"bytes32\"},{\"name\":\"y\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"x\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"y\",\"type\":\"bytes32\"}],\"name\":\"PubkeyChanged\",\"type\":\"event\"}]"
|
|
|
|
// PubkeyResolverFuncSigs maps the 4-byte function signature to its string representation.
|
|
var PubkeyResolverFuncSigs = map[string]string{
|
|
"c8690233": "pubkey(bytes32)",
|
|
"29cd62ea": "setPubkey(bytes32,bytes32,bytes32)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
}
|
|
|
|
// PubkeyResolver is an auto generated Go binding around an Ethereum contract.
|
|
type PubkeyResolver struct {
|
|
PubkeyResolverCaller // Read-only binding to the contract
|
|
PubkeyResolverTransactor // Write-only binding to the contract
|
|
PubkeyResolverFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// PubkeyResolverCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type PubkeyResolverCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// PubkeyResolverTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type PubkeyResolverTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// PubkeyResolverFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type PubkeyResolverFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// PubkeyResolverSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type PubkeyResolverSession struct {
|
|
Contract *PubkeyResolver // 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
|
|
}
|
|
|
|
// PubkeyResolverCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type PubkeyResolverCallerSession struct {
|
|
Contract *PubkeyResolverCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// PubkeyResolverTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type PubkeyResolverTransactorSession struct {
|
|
Contract *PubkeyResolverTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// PubkeyResolverRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type PubkeyResolverRaw struct {
|
|
Contract *PubkeyResolver // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// PubkeyResolverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type PubkeyResolverCallerRaw struct {
|
|
Contract *PubkeyResolverCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// PubkeyResolverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type PubkeyResolverTransactorRaw struct {
|
|
Contract *PubkeyResolverTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewPubkeyResolver creates a new instance of PubkeyResolver, bound to a specific deployed contract.
|
|
func NewPubkeyResolver(address common.Address, backend bind.ContractBackend) (*PubkeyResolver, error) {
|
|
contract, err := bindPubkeyResolver(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PubkeyResolver{PubkeyResolverCaller: PubkeyResolverCaller{contract: contract}, PubkeyResolverTransactor: PubkeyResolverTransactor{contract: contract}, PubkeyResolverFilterer: PubkeyResolverFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewPubkeyResolverCaller creates a new read-only instance of PubkeyResolver, bound to a specific deployed contract.
|
|
func NewPubkeyResolverCaller(address common.Address, caller bind.ContractCaller) (*PubkeyResolverCaller, error) {
|
|
contract, err := bindPubkeyResolver(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PubkeyResolverCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewPubkeyResolverTransactor creates a new write-only instance of PubkeyResolver, bound to a specific deployed contract.
|
|
func NewPubkeyResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*PubkeyResolverTransactor, error) {
|
|
contract, err := bindPubkeyResolver(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PubkeyResolverTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewPubkeyResolverFilterer creates a new log filterer instance of PubkeyResolver, bound to a specific deployed contract.
|
|
func NewPubkeyResolverFilterer(address common.Address, filterer bind.ContractFilterer) (*PubkeyResolverFilterer, error) {
|
|
contract, err := bindPubkeyResolver(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PubkeyResolverFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindPubkeyResolver binds a generic wrapper to an already deployed contract.
|
|
func bindPubkeyResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(PubkeyResolverABI))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
|
|
}
|
|
|
|
// 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 (_PubkeyResolver *PubkeyResolverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _PubkeyResolver.Contract.PubkeyResolverCaller.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_PubkeyResolver *PubkeyResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _PubkeyResolver.Contract.PubkeyResolverTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_PubkeyResolver *PubkeyResolverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _PubkeyResolver.Contract.PubkeyResolverTransactor.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// 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 (_PubkeyResolver *PubkeyResolverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _PubkeyResolver.Contract.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_PubkeyResolver *PubkeyResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _PubkeyResolver.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_PubkeyResolver *PubkeyResolverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _PubkeyResolver.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// Pubkey is a free data retrieval call binding the contract method 0xc8690233.
|
|
//
|
|
// Solidity: function pubkey(bytes32 node) view returns(bytes32 x, bytes32 y)
|
|
func (_PubkeyResolver *PubkeyResolverCaller) Pubkey(opts *bind.CallOpts, node [32]byte) (struct {
|
|
X [32]byte
|
|
Y [32]byte
|
|
}, error) {
|
|
var out []interface{}
|
|
err := _PubkeyResolver.contract.Call(opts, &out, "pubkey", node)
|
|
|
|
outstruct := new(struct {
|
|
X [32]byte
|
|
Y [32]byte
|
|
})
|
|
if err != nil {
|
|
return *outstruct, err
|
|
}
|
|
|
|
outstruct.X = *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
|
|
outstruct.Y = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
|
|
|
|
return *outstruct, err
|
|
|
|
}
|
|
|
|
// Pubkey is a free data retrieval call binding the contract method 0xc8690233.
|
|
//
|
|
// Solidity: function pubkey(bytes32 node) view returns(bytes32 x, bytes32 y)
|
|
func (_PubkeyResolver *PubkeyResolverSession) Pubkey(node [32]byte) (struct {
|
|
X [32]byte
|
|
Y [32]byte
|
|
}, error) {
|
|
return _PubkeyResolver.Contract.Pubkey(&_PubkeyResolver.CallOpts, node)
|
|
}
|
|
|
|
// Pubkey is a free data retrieval call binding the contract method 0xc8690233.
|
|
//
|
|
// Solidity: function pubkey(bytes32 node) view returns(bytes32 x, bytes32 y)
|
|
func (_PubkeyResolver *PubkeyResolverCallerSession) Pubkey(node [32]byte) (struct {
|
|
X [32]byte
|
|
Y [32]byte
|
|
}, error) {
|
|
return _PubkeyResolver.Contract.Pubkey(&_PubkeyResolver.CallOpts, node)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_PubkeyResolver *PubkeyResolverCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _PubkeyResolver.contract.Call(opts, &out, "supportsInterface", interfaceID)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_PubkeyResolver *PubkeyResolverSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _PubkeyResolver.Contract.SupportsInterface(&_PubkeyResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_PubkeyResolver *PubkeyResolverCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _PubkeyResolver.Contract.SupportsInterface(&_PubkeyResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SetPubkey is a paid mutator transaction binding the contract method 0x29cd62ea.
|
|
//
|
|
// Solidity: function setPubkey(bytes32 node, bytes32 x, bytes32 y) returns()
|
|
func (_PubkeyResolver *PubkeyResolverTransactor) SetPubkey(opts *bind.TransactOpts, node [32]byte, x [32]byte, y [32]byte) (*types.Transaction, error) {
|
|
return _PubkeyResolver.contract.Transact(opts, "setPubkey", node, x, y)
|
|
}
|
|
|
|
// SetPubkey is a paid mutator transaction binding the contract method 0x29cd62ea.
|
|
//
|
|
// Solidity: function setPubkey(bytes32 node, bytes32 x, bytes32 y) returns()
|
|
func (_PubkeyResolver *PubkeyResolverSession) SetPubkey(node [32]byte, x [32]byte, y [32]byte) (*types.Transaction, error) {
|
|
return _PubkeyResolver.Contract.SetPubkey(&_PubkeyResolver.TransactOpts, node, x, y)
|
|
}
|
|
|
|
// SetPubkey is a paid mutator transaction binding the contract method 0x29cd62ea.
|
|
//
|
|
// Solidity: function setPubkey(bytes32 node, bytes32 x, bytes32 y) returns()
|
|
func (_PubkeyResolver *PubkeyResolverTransactorSession) SetPubkey(node [32]byte, x [32]byte, y [32]byte) (*types.Transaction, error) {
|
|
return _PubkeyResolver.Contract.SetPubkey(&_PubkeyResolver.TransactOpts, node, x, y)
|
|
}
|
|
|
|
// PubkeyResolverPubkeyChangedIterator is returned from FilterPubkeyChanged and is used to iterate over the raw logs and unpacked data for PubkeyChanged events raised by the PubkeyResolver contract.
|
|
type PubkeyResolverPubkeyChangedIterator struct {
|
|
Event *PubkeyResolverPubkeyChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *PubkeyResolverPubkeyChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PubkeyResolverPubkeyChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PubkeyResolverPubkeyChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *PubkeyResolverPubkeyChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *PubkeyResolverPubkeyChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// PubkeyResolverPubkeyChanged represents a PubkeyChanged event raised by the PubkeyResolver contract.
|
|
type PubkeyResolverPubkeyChanged struct {
|
|
Node [32]byte
|
|
X [32]byte
|
|
Y [32]byte
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterPubkeyChanged is a free log retrieval operation binding the contract event 0x1d6f5e03d3f63eb58751986629a5439baee5079ff04f345becb66e23eb154e46.
|
|
//
|
|
// Solidity: event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y)
|
|
func (_PubkeyResolver *PubkeyResolverFilterer) FilterPubkeyChanged(opts *bind.FilterOpts, node [][32]byte) (*PubkeyResolverPubkeyChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PubkeyResolver.contract.FilterLogs(opts, "PubkeyChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PubkeyResolverPubkeyChangedIterator{contract: _PubkeyResolver.contract, event: "PubkeyChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchPubkeyChanged is a free log subscription operation binding the contract event 0x1d6f5e03d3f63eb58751986629a5439baee5079ff04f345becb66e23eb154e46.
|
|
//
|
|
// Solidity: event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y)
|
|
func (_PubkeyResolver *PubkeyResolverFilterer) WatchPubkeyChanged(opts *bind.WatchOpts, sink chan<- *PubkeyResolverPubkeyChanged, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PubkeyResolver.contract.WatchLogs(opts, "PubkeyChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(PubkeyResolverPubkeyChanged)
|
|
if err := _PubkeyResolver.contract.UnpackLog(event, "PubkeyChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParsePubkeyChanged is a log parse operation binding the contract event 0x1d6f5e03d3f63eb58751986629a5439baee5079ff04f345becb66e23eb154e46.
|
|
//
|
|
// Solidity: event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y)
|
|
func (_PubkeyResolver *PubkeyResolverFilterer) ParsePubkeyChanged(log types.Log) (*PubkeyResolverPubkeyChanged, error) {
|
|
event := new(PubkeyResolverPubkeyChanged)
|
|
if err := _PubkeyResolver.contract.UnpackLog(event, "PubkeyChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// PublicResolverABI is the input ABI used to generate the binding from.
|
|
const PublicResolverABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"setDNSRecords\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"key\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"string\"}],\"name\":\"setText\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"interfaceImplementer\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"contentTypes\",\"type\":\"uint256\"}],\"name\":\"ABI\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"},{\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"x\",\"type\":\"bytes32\"},{\"name\":\"y\",\"type\":\"bytes32\"}],\"name\":\"setPubkey\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"hash\",\"type\":\"bytes\"}],\"name\":\"setContenthash\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"addr\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"target\",\"type\":\"address\"},{\"name\":\"isAuthorised\",\"type\":\"bool\"}],\"name\":\"setAuthorisation\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"name\",\"type\":\"bytes32\"}],\"name\":\"hasDNSRecords\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"key\",\"type\":\"string\"}],\"name\":\"text\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"contentType\",\"type\":\"uint256\"},{\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"setABI\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"name\",\"type\":\"string\"}],\"name\":\"setName\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"coinType\",\"type\":\"uint256\"},{\"name\":\"a\",\"type\":\"bytes\"}],\"name\":\"setAddr\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"name\",\"type\":\"bytes32\"},{\"name\":\"resource\",\"type\":\"uint16\"}],\"name\":\"dnsRecord\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"data\",\"type\":\"bytes[]\"}],\"name\":\"multicall\",\"outputs\":[{\"name\":\"results\",\"type\":\"bytes[]\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"clearDNSZone\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"contenthash\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"pubkey\",\"outputs\":[{\"name\":\"x\",\"type\":\"bytes32\"},{\"name\":\"y\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"a\",\"type\":\"address\"}],\"name\":\"setAddr\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"interfaceID\",\"type\":\"bytes4\"},{\"name\":\"implementer\",\"type\":\"address\"}],\"name\":\"setInterface\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"coinType\",\"type\":\"uint256\"}],\"name\":\"addr\",\"outputs\":[{\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\"},{\"name\":\"\",\"type\":\"address\"},{\"name\":\"\",\"type\":\"address\"}],\"name\":\"authorisations\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"target\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"isAuthorised\",\"type\":\"bool\"}],\"name\":\"AuthorisationChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"indexedKey\",\"type\":\"string\"},{\"indexed\":false,\"name\":\"key\",\"type\":\"string\"}],\"name\":\"TextChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"x\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"y\",\"type\":\"bytes32\"}],\"name\":\"PubkeyChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"name\",\"type\":\"string\"}],\"name\":\"NameChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"interfaceID\",\"type\":\"bytes4\"},{\"indexed\":false,\"name\":\"implementer\",\"type\":\"address\"}],\"name\":\"InterfaceChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"name\",\"type\":\"bytes\"},{\"indexed\":false,\"name\":\"resource\",\"type\":\"uint16\"},{\"indexed\":false,\"name\":\"record\",\"type\":\"bytes\"}],\"name\":\"DNSRecordChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"name\",\"type\":\"bytes\"},{\"indexed\":false,\"name\":\"resource\",\"type\":\"uint16\"}],\"name\":\"DNSRecordDeleted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"}],\"name\":\"DNSZoneCleared\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"hash\",\"type\":\"bytes\"}],\"name\":\"ContenthashChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"a\",\"type\":\"address\"}],\"name\":\"AddrChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":false,\"name\":\"coinType\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"newAddress\",\"type\":\"bytes\"}],\"name\":\"AddressChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"contentType\",\"type\":\"uint256\"}],\"name\":\"ABIChanged\",\"type\":\"event\"}]"
|
|
|
|
// PublicResolverFuncSigs maps the 4-byte function signature to its string representation.
|
|
var PublicResolverFuncSigs = map[string]string{
|
|
"2203ab56": "ABI(bytes32,uint256)",
|
|
"3b3b57de": "addr(bytes32)",
|
|
"f1cb7e06": "addr(bytes32,uint256)",
|
|
"f86bc879": "authorisations(bytes32,address,address)",
|
|
"ad5780af": "clearDNSZone(bytes32)",
|
|
"bc1c58d1": "contenthash(bytes32)",
|
|
"a8fa5682": "dnsRecord(bytes32,bytes32,uint16)",
|
|
"4cbf6ba4": "hasDNSRecords(bytes32,bytes32)",
|
|
"124a319c": "interfaceImplementer(bytes32,bytes4)",
|
|
"ac9650d8": "multicall(bytes[])",
|
|
"691f3431": "name(bytes32)",
|
|
"c8690233": "pubkey(bytes32)",
|
|
"623195b0": "setABI(bytes32,uint256,bytes)",
|
|
"d5fa2b00": "setAddr(bytes32,address)",
|
|
"8b95dd71": "setAddr(bytes32,uint256,bytes)",
|
|
"3e9ce794": "setAuthorisation(bytes32,address,bool)",
|
|
"304e6ade": "setContenthash(bytes32,bytes)",
|
|
"0af179d7": "setDNSRecords(bytes32,bytes)",
|
|
"e59d895d": "setInterface(bytes32,bytes4,address)",
|
|
"77372213": "setName(bytes32,string)",
|
|
"29cd62ea": "setPubkey(bytes32,bytes32,bytes32)",
|
|
"10f13a8c": "setText(bytes32,string,string)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
"59d1d43c": "text(bytes32,string)",
|
|
}
|
|
|
|
// PublicResolver is an auto generated Go binding around an Ethereum contract.
|
|
type PublicResolver struct {
|
|
PublicResolverCaller // Read-only binding to the contract
|
|
PublicResolverTransactor // Write-only binding to the contract
|
|
PublicResolverFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// PublicResolverCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type PublicResolverCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// PublicResolverTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type PublicResolverTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// PublicResolverFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type PublicResolverFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// PublicResolverSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type PublicResolverSession struct {
|
|
Contract *PublicResolver // 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
|
|
}
|
|
|
|
// PublicResolverCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type PublicResolverCallerSession struct {
|
|
Contract *PublicResolverCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// PublicResolverTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type PublicResolverTransactorSession struct {
|
|
Contract *PublicResolverTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// PublicResolverRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type PublicResolverRaw struct {
|
|
Contract *PublicResolver // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// PublicResolverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type PublicResolverCallerRaw struct {
|
|
Contract *PublicResolverCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// PublicResolverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type PublicResolverTransactorRaw struct {
|
|
Contract *PublicResolverTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewPublicResolver creates a new instance of PublicResolver, bound to a specific deployed contract.
|
|
func NewPublicResolver(address common.Address, backend bind.ContractBackend) (*PublicResolver, error) {
|
|
contract, err := bindPublicResolver(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolver{PublicResolverCaller: PublicResolverCaller{contract: contract}, PublicResolverTransactor: PublicResolverTransactor{contract: contract}, PublicResolverFilterer: PublicResolverFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewPublicResolverCaller creates a new read-only instance of PublicResolver, bound to a specific deployed contract.
|
|
func NewPublicResolverCaller(address common.Address, caller bind.ContractCaller) (*PublicResolverCaller, error) {
|
|
contract, err := bindPublicResolver(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolverCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewPublicResolverTransactor creates a new write-only instance of PublicResolver, bound to a specific deployed contract.
|
|
func NewPublicResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*PublicResolverTransactor, error) {
|
|
contract, err := bindPublicResolver(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolverTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewPublicResolverFilterer creates a new log filterer instance of PublicResolver, bound to a specific deployed contract.
|
|
func NewPublicResolverFilterer(address common.Address, filterer bind.ContractFilterer) (*PublicResolverFilterer, error) {
|
|
contract, err := bindPublicResolver(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolverFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindPublicResolver binds a generic wrapper to an already deployed contract.
|
|
func bindPublicResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(PublicResolverABI))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
|
|
}
|
|
|
|
// 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 (_PublicResolver *PublicResolverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _PublicResolver.Contract.PublicResolverCaller.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_PublicResolver *PublicResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.PublicResolverTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_PublicResolver *PublicResolverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.PublicResolverTransactor.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// 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 (_PublicResolver *PublicResolverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _PublicResolver.Contract.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_PublicResolver *PublicResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_PublicResolver *PublicResolverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// ABI is a free data retrieval call binding the contract method 0x2203ab56.
|
|
//
|
|
// Solidity: function ABI(bytes32 node, uint256 contentTypes) view returns(uint256, bytes)
|
|
func (_PublicResolver *PublicResolverCaller) ABI(opts *bind.CallOpts, node [32]byte, contentTypes *big.Int) (*big.Int, []byte, error) {
|
|
var out []interface{}
|
|
err := _PublicResolver.contract.Call(opts, &out, "ABI", node, contentTypes)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), *new([]byte), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
out1 := *abi.ConvertType(out[1], new([]byte)).(*[]byte)
|
|
|
|
return out0, out1, err
|
|
|
|
}
|
|
|
|
// ABI is a free data retrieval call binding the contract method 0x2203ab56.
|
|
//
|
|
// Solidity: function ABI(bytes32 node, uint256 contentTypes) view returns(uint256, bytes)
|
|
func (_PublicResolver *PublicResolverSession) ABI(node [32]byte, contentTypes *big.Int) (*big.Int, []byte, error) {
|
|
return _PublicResolver.Contract.ABI(&_PublicResolver.CallOpts, node, contentTypes)
|
|
}
|
|
|
|
// ABI is a free data retrieval call binding the contract method 0x2203ab56.
|
|
//
|
|
// Solidity: function ABI(bytes32 node, uint256 contentTypes) view returns(uint256, bytes)
|
|
func (_PublicResolver *PublicResolverCallerSession) ABI(node [32]byte, contentTypes *big.Int) (*big.Int, []byte, error) {
|
|
return _PublicResolver.Contract.ABI(&_PublicResolver.CallOpts, node, contentTypes)
|
|
}
|
|
|
|
// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
|
|
//
|
|
// Solidity: function addr(bytes32 node) view returns(address)
|
|
func (_PublicResolver *PublicResolverCaller) Addr(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _PublicResolver.contract.Call(opts, &out, "addr", node)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
|
|
//
|
|
// Solidity: function addr(bytes32 node) view returns(address)
|
|
func (_PublicResolver *PublicResolverSession) Addr(node [32]byte) (common.Address, error) {
|
|
return _PublicResolver.Contract.Addr(&_PublicResolver.CallOpts, node)
|
|
}
|
|
|
|
// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
|
|
//
|
|
// Solidity: function addr(bytes32 node) view returns(address)
|
|
func (_PublicResolver *PublicResolverCallerSession) Addr(node [32]byte) (common.Address, error) {
|
|
return _PublicResolver.Contract.Addr(&_PublicResolver.CallOpts, node)
|
|
}
|
|
|
|
// Addr0 is a free data retrieval call binding the contract method 0xf1cb7e06.
|
|
//
|
|
// Solidity: function addr(bytes32 node, uint256 coinType) view returns(bytes)
|
|
func (_PublicResolver *PublicResolverCaller) Addr0(opts *bind.CallOpts, node [32]byte, coinType *big.Int) ([]byte, error) {
|
|
var out []interface{}
|
|
err := _PublicResolver.contract.Call(opts, &out, "addr0", node, coinType)
|
|
|
|
if err != nil {
|
|
return *new([]byte), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Addr0 is a free data retrieval call binding the contract method 0xf1cb7e06.
|
|
//
|
|
// Solidity: function addr(bytes32 node, uint256 coinType) view returns(bytes)
|
|
func (_PublicResolver *PublicResolverSession) Addr0(node [32]byte, coinType *big.Int) ([]byte, error) {
|
|
return _PublicResolver.Contract.Addr0(&_PublicResolver.CallOpts, node, coinType)
|
|
}
|
|
|
|
// Addr0 is a free data retrieval call binding the contract method 0xf1cb7e06.
|
|
//
|
|
// Solidity: function addr(bytes32 node, uint256 coinType) view returns(bytes)
|
|
func (_PublicResolver *PublicResolverCallerSession) Addr0(node [32]byte, coinType *big.Int) ([]byte, error) {
|
|
return _PublicResolver.Contract.Addr0(&_PublicResolver.CallOpts, node, coinType)
|
|
}
|
|
|
|
// Authorisations is a free data retrieval call binding the contract method 0xf86bc879.
|
|
//
|
|
// Solidity: function authorisations(bytes32 , address , address ) view returns(bool)
|
|
func (_PublicResolver *PublicResolverCaller) Authorisations(opts *bind.CallOpts, arg0 [32]byte, arg1 common.Address, arg2 common.Address) (bool, error) {
|
|
var out []interface{}
|
|
err := _PublicResolver.contract.Call(opts, &out, "authorisations", arg0, arg1, arg2)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Authorisations is a free data retrieval call binding the contract method 0xf86bc879.
|
|
//
|
|
// Solidity: function authorisations(bytes32 , address , address ) view returns(bool)
|
|
func (_PublicResolver *PublicResolverSession) Authorisations(arg0 [32]byte, arg1 common.Address, arg2 common.Address) (bool, error) {
|
|
return _PublicResolver.Contract.Authorisations(&_PublicResolver.CallOpts, arg0, arg1, arg2)
|
|
}
|
|
|
|
// Authorisations is a free data retrieval call binding the contract method 0xf86bc879.
|
|
//
|
|
// Solidity: function authorisations(bytes32 , address , address ) view returns(bool)
|
|
func (_PublicResolver *PublicResolverCallerSession) Authorisations(arg0 [32]byte, arg1 common.Address, arg2 common.Address) (bool, error) {
|
|
return _PublicResolver.Contract.Authorisations(&_PublicResolver.CallOpts, arg0, arg1, arg2)
|
|
}
|
|
|
|
// Contenthash is a free data retrieval call binding the contract method 0xbc1c58d1.
|
|
//
|
|
// Solidity: function contenthash(bytes32 node) view returns(bytes)
|
|
func (_PublicResolver *PublicResolverCaller) Contenthash(opts *bind.CallOpts, node [32]byte) ([]byte, error) {
|
|
var out []interface{}
|
|
err := _PublicResolver.contract.Call(opts, &out, "contenthash", node)
|
|
|
|
if err != nil {
|
|
return *new([]byte), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Contenthash is a free data retrieval call binding the contract method 0xbc1c58d1.
|
|
//
|
|
// Solidity: function contenthash(bytes32 node) view returns(bytes)
|
|
func (_PublicResolver *PublicResolverSession) Contenthash(node [32]byte) ([]byte, error) {
|
|
return _PublicResolver.Contract.Contenthash(&_PublicResolver.CallOpts, node)
|
|
}
|
|
|
|
// Contenthash is a free data retrieval call binding the contract method 0xbc1c58d1.
|
|
//
|
|
// Solidity: function contenthash(bytes32 node) view returns(bytes)
|
|
func (_PublicResolver *PublicResolverCallerSession) Contenthash(node [32]byte) ([]byte, error) {
|
|
return _PublicResolver.Contract.Contenthash(&_PublicResolver.CallOpts, node)
|
|
}
|
|
|
|
// DnsRecord is a free data retrieval call binding the contract method 0xa8fa5682.
|
|
//
|
|
// Solidity: function dnsRecord(bytes32 node, bytes32 name, uint16 resource) view returns(bytes)
|
|
func (_PublicResolver *PublicResolverCaller) DnsRecord(opts *bind.CallOpts, node [32]byte, name [32]byte, resource uint16) ([]byte, error) {
|
|
var out []interface{}
|
|
err := _PublicResolver.contract.Call(opts, &out, "dnsRecord", node, name, resource)
|
|
|
|
if err != nil {
|
|
return *new([]byte), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// DnsRecord is a free data retrieval call binding the contract method 0xa8fa5682.
|
|
//
|
|
// Solidity: function dnsRecord(bytes32 node, bytes32 name, uint16 resource) view returns(bytes)
|
|
func (_PublicResolver *PublicResolverSession) DnsRecord(node [32]byte, name [32]byte, resource uint16) ([]byte, error) {
|
|
return _PublicResolver.Contract.DnsRecord(&_PublicResolver.CallOpts, node, name, resource)
|
|
}
|
|
|
|
// DnsRecord is a free data retrieval call binding the contract method 0xa8fa5682.
|
|
//
|
|
// Solidity: function dnsRecord(bytes32 node, bytes32 name, uint16 resource) view returns(bytes)
|
|
func (_PublicResolver *PublicResolverCallerSession) DnsRecord(node [32]byte, name [32]byte, resource uint16) ([]byte, error) {
|
|
return _PublicResolver.Contract.DnsRecord(&_PublicResolver.CallOpts, node, name, resource)
|
|
}
|
|
|
|
// HasDNSRecords is a free data retrieval call binding the contract method 0x4cbf6ba4.
|
|
//
|
|
// Solidity: function hasDNSRecords(bytes32 node, bytes32 name) view returns(bool)
|
|
func (_PublicResolver *PublicResolverCaller) HasDNSRecords(opts *bind.CallOpts, node [32]byte, name [32]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _PublicResolver.contract.Call(opts, &out, "hasDNSRecords", node, name)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// HasDNSRecords is a free data retrieval call binding the contract method 0x4cbf6ba4.
|
|
//
|
|
// Solidity: function hasDNSRecords(bytes32 node, bytes32 name) view returns(bool)
|
|
func (_PublicResolver *PublicResolverSession) HasDNSRecords(node [32]byte, name [32]byte) (bool, error) {
|
|
return _PublicResolver.Contract.HasDNSRecords(&_PublicResolver.CallOpts, node, name)
|
|
}
|
|
|
|
// HasDNSRecords is a free data retrieval call binding the contract method 0x4cbf6ba4.
|
|
//
|
|
// Solidity: function hasDNSRecords(bytes32 node, bytes32 name) view returns(bool)
|
|
func (_PublicResolver *PublicResolverCallerSession) HasDNSRecords(node [32]byte, name [32]byte) (bool, error) {
|
|
return _PublicResolver.Contract.HasDNSRecords(&_PublicResolver.CallOpts, node, name)
|
|
}
|
|
|
|
// InterfaceImplementer is a free data retrieval call binding the contract method 0x124a319c.
|
|
//
|
|
// Solidity: function interfaceImplementer(bytes32 node, bytes4 interfaceID) view returns(address)
|
|
func (_PublicResolver *PublicResolverCaller) InterfaceImplementer(opts *bind.CallOpts, node [32]byte, interfaceID [4]byte) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _PublicResolver.contract.Call(opts, &out, "interfaceImplementer", node, interfaceID)
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// InterfaceImplementer is a free data retrieval call binding the contract method 0x124a319c.
|
|
//
|
|
// Solidity: function interfaceImplementer(bytes32 node, bytes4 interfaceID) view returns(address)
|
|
func (_PublicResolver *PublicResolverSession) InterfaceImplementer(node [32]byte, interfaceID [4]byte) (common.Address, error) {
|
|
return _PublicResolver.Contract.InterfaceImplementer(&_PublicResolver.CallOpts, node, interfaceID)
|
|
}
|
|
|
|
// InterfaceImplementer is a free data retrieval call binding the contract method 0x124a319c.
|
|
//
|
|
// Solidity: function interfaceImplementer(bytes32 node, bytes4 interfaceID) view returns(address)
|
|
func (_PublicResolver *PublicResolverCallerSession) InterfaceImplementer(node [32]byte, interfaceID [4]byte) (common.Address, error) {
|
|
return _PublicResolver.Contract.InterfaceImplementer(&_PublicResolver.CallOpts, node, interfaceID)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x691f3431.
|
|
//
|
|
// Solidity: function name(bytes32 node) view returns(string)
|
|
func (_PublicResolver *PublicResolverCaller) Name(opts *bind.CallOpts, node [32]byte) (string, error) {
|
|
var out []interface{}
|
|
err := _PublicResolver.contract.Call(opts, &out, "name", node)
|
|
|
|
if err != nil {
|
|
return *new(string), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(string)).(*string)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x691f3431.
|
|
//
|
|
// Solidity: function name(bytes32 node) view returns(string)
|
|
func (_PublicResolver *PublicResolverSession) Name(node [32]byte) (string, error) {
|
|
return _PublicResolver.Contract.Name(&_PublicResolver.CallOpts, node)
|
|
}
|
|
|
|
// Name is a free data retrieval call binding the contract method 0x691f3431.
|
|
//
|
|
// Solidity: function name(bytes32 node) view returns(string)
|
|
func (_PublicResolver *PublicResolverCallerSession) Name(node [32]byte) (string, error) {
|
|
return _PublicResolver.Contract.Name(&_PublicResolver.CallOpts, node)
|
|
}
|
|
|
|
// Pubkey is a free data retrieval call binding the contract method 0xc8690233.
|
|
//
|
|
// Solidity: function pubkey(bytes32 node) view returns(bytes32 x, bytes32 y)
|
|
func (_PublicResolver *PublicResolverCaller) Pubkey(opts *bind.CallOpts, node [32]byte) (struct {
|
|
X [32]byte
|
|
Y [32]byte
|
|
}, error) {
|
|
var out []interface{}
|
|
err := _PublicResolver.contract.Call(opts, &out, "pubkey", node)
|
|
|
|
outstruct := new(struct {
|
|
X [32]byte
|
|
Y [32]byte
|
|
})
|
|
if err != nil {
|
|
return *outstruct, err
|
|
}
|
|
|
|
outstruct.X = *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
|
|
outstruct.Y = *abi.ConvertType(out[1], new([32]byte)).(*[32]byte)
|
|
|
|
return *outstruct, err
|
|
|
|
}
|
|
|
|
// Pubkey is a free data retrieval call binding the contract method 0xc8690233.
|
|
//
|
|
// Solidity: function pubkey(bytes32 node) view returns(bytes32 x, bytes32 y)
|
|
func (_PublicResolver *PublicResolverSession) Pubkey(node [32]byte) (struct {
|
|
X [32]byte
|
|
Y [32]byte
|
|
}, error) {
|
|
return _PublicResolver.Contract.Pubkey(&_PublicResolver.CallOpts, node)
|
|
}
|
|
|
|
// Pubkey is a free data retrieval call binding the contract method 0xc8690233.
|
|
//
|
|
// Solidity: function pubkey(bytes32 node) view returns(bytes32 x, bytes32 y)
|
|
func (_PublicResolver *PublicResolverCallerSession) Pubkey(node [32]byte) (struct {
|
|
X [32]byte
|
|
Y [32]byte
|
|
}, error) {
|
|
return _PublicResolver.Contract.Pubkey(&_PublicResolver.CallOpts, node)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_PublicResolver *PublicResolverCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _PublicResolver.contract.Call(opts, &out, "supportsInterface", interfaceID)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_PublicResolver *PublicResolverSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _PublicResolver.Contract.SupportsInterface(&_PublicResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_PublicResolver *PublicResolverCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _PublicResolver.Contract.SupportsInterface(&_PublicResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// Text is a free data retrieval call binding the contract method 0x59d1d43c.
|
|
//
|
|
// Solidity: function text(bytes32 node, string key) view returns(string)
|
|
func (_PublicResolver *PublicResolverCaller) Text(opts *bind.CallOpts, node [32]byte, key string) (string, error) {
|
|
var out []interface{}
|
|
err := _PublicResolver.contract.Call(opts, &out, "text", node, key)
|
|
|
|
if err != nil {
|
|
return *new(string), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(string)).(*string)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Text is a free data retrieval call binding the contract method 0x59d1d43c.
|
|
//
|
|
// Solidity: function text(bytes32 node, string key) view returns(string)
|
|
func (_PublicResolver *PublicResolverSession) Text(node [32]byte, key string) (string, error) {
|
|
return _PublicResolver.Contract.Text(&_PublicResolver.CallOpts, node, key)
|
|
}
|
|
|
|
// Text is a free data retrieval call binding the contract method 0x59d1d43c.
|
|
//
|
|
// Solidity: function text(bytes32 node, string key) view returns(string)
|
|
func (_PublicResolver *PublicResolverCallerSession) Text(node [32]byte, key string) (string, error) {
|
|
return _PublicResolver.Contract.Text(&_PublicResolver.CallOpts, node, key)
|
|
}
|
|
|
|
// ClearDNSZone is a paid mutator transaction binding the contract method 0xad5780af.
|
|
//
|
|
// Solidity: function clearDNSZone(bytes32 node) returns()
|
|
func (_PublicResolver *PublicResolverTransactor) ClearDNSZone(opts *bind.TransactOpts, node [32]byte) (*types.Transaction, error) {
|
|
return _PublicResolver.contract.Transact(opts, "clearDNSZone", node)
|
|
}
|
|
|
|
// ClearDNSZone is a paid mutator transaction binding the contract method 0xad5780af.
|
|
//
|
|
// Solidity: function clearDNSZone(bytes32 node) returns()
|
|
func (_PublicResolver *PublicResolverSession) ClearDNSZone(node [32]byte) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.ClearDNSZone(&_PublicResolver.TransactOpts, node)
|
|
}
|
|
|
|
// ClearDNSZone is a paid mutator transaction binding the contract method 0xad5780af.
|
|
//
|
|
// Solidity: function clearDNSZone(bytes32 node) returns()
|
|
func (_PublicResolver *PublicResolverTransactorSession) ClearDNSZone(node [32]byte) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.ClearDNSZone(&_PublicResolver.TransactOpts, node)
|
|
}
|
|
|
|
// Multicall is a paid mutator transaction binding the contract method 0xac9650d8.
|
|
//
|
|
// Solidity: function multicall(bytes[] data) returns(bytes[] results)
|
|
func (_PublicResolver *PublicResolverTransactor) Multicall(opts *bind.TransactOpts, data [][]byte) (*types.Transaction, error) {
|
|
return _PublicResolver.contract.Transact(opts, "multicall", data)
|
|
}
|
|
|
|
// Multicall is a paid mutator transaction binding the contract method 0xac9650d8.
|
|
//
|
|
// Solidity: function multicall(bytes[] data) returns(bytes[] results)
|
|
func (_PublicResolver *PublicResolverSession) Multicall(data [][]byte) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.Multicall(&_PublicResolver.TransactOpts, data)
|
|
}
|
|
|
|
// Multicall is a paid mutator transaction binding the contract method 0xac9650d8.
|
|
//
|
|
// Solidity: function multicall(bytes[] data) returns(bytes[] results)
|
|
func (_PublicResolver *PublicResolverTransactorSession) Multicall(data [][]byte) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.Multicall(&_PublicResolver.TransactOpts, data)
|
|
}
|
|
|
|
// SetABI is a paid mutator transaction binding the contract method 0x623195b0.
|
|
//
|
|
// Solidity: function setABI(bytes32 node, uint256 contentType, bytes data) returns()
|
|
func (_PublicResolver *PublicResolverTransactor) SetABI(opts *bind.TransactOpts, node [32]byte, contentType *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _PublicResolver.contract.Transact(opts, "setABI", node, contentType, data)
|
|
}
|
|
|
|
// SetABI is a paid mutator transaction binding the contract method 0x623195b0.
|
|
//
|
|
// Solidity: function setABI(bytes32 node, uint256 contentType, bytes data) returns()
|
|
func (_PublicResolver *PublicResolverSession) SetABI(node [32]byte, contentType *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetABI(&_PublicResolver.TransactOpts, node, contentType, data)
|
|
}
|
|
|
|
// SetABI is a paid mutator transaction binding the contract method 0x623195b0.
|
|
//
|
|
// Solidity: function setABI(bytes32 node, uint256 contentType, bytes data) returns()
|
|
func (_PublicResolver *PublicResolverTransactorSession) SetABI(node [32]byte, contentType *big.Int, data []byte) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetABI(&_PublicResolver.TransactOpts, node, contentType, data)
|
|
}
|
|
|
|
// SetAddr is a paid mutator transaction binding the contract method 0x8b95dd71.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, uint256 coinType, bytes a) returns()
|
|
func (_PublicResolver *PublicResolverTransactor) SetAddr(opts *bind.TransactOpts, node [32]byte, coinType *big.Int, a []byte) (*types.Transaction, error) {
|
|
return _PublicResolver.contract.Transact(opts, "setAddr", node, coinType, a)
|
|
}
|
|
|
|
// SetAddr is a paid mutator transaction binding the contract method 0x8b95dd71.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, uint256 coinType, bytes a) returns()
|
|
func (_PublicResolver *PublicResolverSession) SetAddr(node [32]byte, coinType *big.Int, a []byte) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetAddr(&_PublicResolver.TransactOpts, node, coinType, a)
|
|
}
|
|
|
|
// SetAddr is a paid mutator transaction binding the contract method 0x8b95dd71.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, uint256 coinType, bytes a) returns()
|
|
func (_PublicResolver *PublicResolverTransactorSession) SetAddr(node [32]byte, coinType *big.Int, a []byte) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetAddr(&_PublicResolver.TransactOpts, node, coinType, a)
|
|
}
|
|
|
|
// SetAddr0 is a paid mutator transaction binding the contract method 0xd5fa2b00.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, address a) returns()
|
|
func (_PublicResolver *PublicResolverTransactor) SetAddr0(opts *bind.TransactOpts, node [32]byte, a common.Address) (*types.Transaction, error) {
|
|
return _PublicResolver.contract.Transact(opts, "setAddr0", node, a)
|
|
}
|
|
|
|
// SetAddr0 is a paid mutator transaction binding the contract method 0xd5fa2b00.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, address a) returns()
|
|
func (_PublicResolver *PublicResolverSession) SetAddr0(node [32]byte, a common.Address) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetAddr0(&_PublicResolver.TransactOpts, node, a)
|
|
}
|
|
|
|
// SetAddr0 is a paid mutator transaction binding the contract method 0xd5fa2b00.
|
|
//
|
|
// Solidity: function setAddr(bytes32 node, address a) returns()
|
|
func (_PublicResolver *PublicResolverTransactorSession) SetAddr0(node [32]byte, a common.Address) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetAddr0(&_PublicResolver.TransactOpts, node, a)
|
|
}
|
|
|
|
// SetAuthorisation is a paid mutator transaction binding the contract method 0x3e9ce794.
|
|
//
|
|
// Solidity: function setAuthorisation(bytes32 node, address target, bool isAuthorised) returns()
|
|
func (_PublicResolver *PublicResolverTransactor) SetAuthorisation(opts *bind.TransactOpts, node [32]byte, target common.Address, isAuthorised bool) (*types.Transaction, error) {
|
|
return _PublicResolver.contract.Transact(opts, "setAuthorisation", node, target, isAuthorised)
|
|
}
|
|
|
|
// SetAuthorisation is a paid mutator transaction binding the contract method 0x3e9ce794.
|
|
//
|
|
// Solidity: function setAuthorisation(bytes32 node, address target, bool isAuthorised) returns()
|
|
func (_PublicResolver *PublicResolverSession) SetAuthorisation(node [32]byte, target common.Address, isAuthorised bool) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetAuthorisation(&_PublicResolver.TransactOpts, node, target, isAuthorised)
|
|
}
|
|
|
|
// SetAuthorisation is a paid mutator transaction binding the contract method 0x3e9ce794.
|
|
//
|
|
// Solidity: function setAuthorisation(bytes32 node, address target, bool isAuthorised) returns()
|
|
func (_PublicResolver *PublicResolverTransactorSession) SetAuthorisation(node [32]byte, target common.Address, isAuthorised bool) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetAuthorisation(&_PublicResolver.TransactOpts, node, target, isAuthorised)
|
|
}
|
|
|
|
// SetContenthash is a paid mutator transaction binding the contract method 0x304e6ade.
|
|
//
|
|
// Solidity: function setContenthash(bytes32 node, bytes hash) returns()
|
|
func (_PublicResolver *PublicResolverTransactor) SetContenthash(opts *bind.TransactOpts, node [32]byte, hash []byte) (*types.Transaction, error) {
|
|
return _PublicResolver.contract.Transact(opts, "setContenthash", node, hash)
|
|
}
|
|
|
|
// SetContenthash is a paid mutator transaction binding the contract method 0x304e6ade.
|
|
//
|
|
// Solidity: function setContenthash(bytes32 node, bytes hash) returns()
|
|
func (_PublicResolver *PublicResolverSession) SetContenthash(node [32]byte, hash []byte) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetContenthash(&_PublicResolver.TransactOpts, node, hash)
|
|
}
|
|
|
|
// SetContenthash is a paid mutator transaction binding the contract method 0x304e6ade.
|
|
//
|
|
// Solidity: function setContenthash(bytes32 node, bytes hash) returns()
|
|
func (_PublicResolver *PublicResolverTransactorSession) SetContenthash(node [32]byte, hash []byte) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetContenthash(&_PublicResolver.TransactOpts, node, hash)
|
|
}
|
|
|
|
// SetDNSRecords is a paid mutator transaction binding the contract method 0x0af179d7.
|
|
//
|
|
// Solidity: function setDNSRecords(bytes32 node, bytes data) returns()
|
|
func (_PublicResolver *PublicResolverTransactor) SetDNSRecords(opts *bind.TransactOpts, node [32]byte, data []byte) (*types.Transaction, error) {
|
|
return _PublicResolver.contract.Transact(opts, "setDNSRecords", node, data)
|
|
}
|
|
|
|
// SetDNSRecords is a paid mutator transaction binding the contract method 0x0af179d7.
|
|
//
|
|
// Solidity: function setDNSRecords(bytes32 node, bytes data) returns()
|
|
func (_PublicResolver *PublicResolverSession) SetDNSRecords(node [32]byte, data []byte) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetDNSRecords(&_PublicResolver.TransactOpts, node, data)
|
|
}
|
|
|
|
// SetDNSRecords is a paid mutator transaction binding the contract method 0x0af179d7.
|
|
//
|
|
// Solidity: function setDNSRecords(bytes32 node, bytes data) returns()
|
|
func (_PublicResolver *PublicResolverTransactorSession) SetDNSRecords(node [32]byte, data []byte) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetDNSRecords(&_PublicResolver.TransactOpts, node, data)
|
|
}
|
|
|
|
// SetInterface is a paid mutator transaction binding the contract method 0xe59d895d.
|
|
//
|
|
// Solidity: function setInterface(bytes32 node, bytes4 interfaceID, address implementer) returns()
|
|
func (_PublicResolver *PublicResolverTransactor) SetInterface(opts *bind.TransactOpts, node [32]byte, interfaceID [4]byte, implementer common.Address) (*types.Transaction, error) {
|
|
return _PublicResolver.contract.Transact(opts, "setInterface", node, interfaceID, implementer)
|
|
}
|
|
|
|
// SetInterface is a paid mutator transaction binding the contract method 0xe59d895d.
|
|
//
|
|
// Solidity: function setInterface(bytes32 node, bytes4 interfaceID, address implementer) returns()
|
|
func (_PublicResolver *PublicResolverSession) SetInterface(node [32]byte, interfaceID [4]byte, implementer common.Address) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetInterface(&_PublicResolver.TransactOpts, node, interfaceID, implementer)
|
|
}
|
|
|
|
// SetInterface is a paid mutator transaction binding the contract method 0xe59d895d.
|
|
//
|
|
// Solidity: function setInterface(bytes32 node, bytes4 interfaceID, address implementer) returns()
|
|
func (_PublicResolver *PublicResolverTransactorSession) SetInterface(node [32]byte, interfaceID [4]byte, implementer common.Address) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetInterface(&_PublicResolver.TransactOpts, node, interfaceID, implementer)
|
|
}
|
|
|
|
// SetName is a paid mutator transaction binding the contract method 0x77372213.
|
|
//
|
|
// Solidity: function setName(bytes32 node, string name) returns()
|
|
func (_PublicResolver *PublicResolverTransactor) SetName(opts *bind.TransactOpts, node [32]byte, name string) (*types.Transaction, error) {
|
|
return _PublicResolver.contract.Transact(opts, "setName", node, name)
|
|
}
|
|
|
|
// SetName is a paid mutator transaction binding the contract method 0x77372213.
|
|
//
|
|
// Solidity: function setName(bytes32 node, string name) returns()
|
|
func (_PublicResolver *PublicResolverSession) SetName(node [32]byte, name string) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetName(&_PublicResolver.TransactOpts, node, name)
|
|
}
|
|
|
|
// SetName is a paid mutator transaction binding the contract method 0x77372213.
|
|
//
|
|
// Solidity: function setName(bytes32 node, string name) returns()
|
|
func (_PublicResolver *PublicResolverTransactorSession) SetName(node [32]byte, name string) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetName(&_PublicResolver.TransactOpts, node, name)
|
|
}
|
|
|
|
// SetPubkey is a paid mutator transaction binding the contract method 0x29cd62ea.
|
|
//
|
|
// Solidity: function setPubkey(bytes32 node, bytes32 x, bytes32 y) returns()
|
|
func (_PublicResolver *PublicResolverTransactor) SetPubkey(opts *bind.TransactOpts, node [32]byte, x [32]byte, y [32]byte) (*types.Transaction, error) {
|
|
return _PublicResolver.contract.Transact(opts, "setPubkey", node, x, y)
|
|
}
|
|
|
|
// SetPubkey is a paid mutator transaction binding the contract method 0x29cd62ea.
|
|
//
|
|
// Solidity: function setPubkey(bytes32 node, bytes32 x, bytes32 y) returns()
|
|
func (_PublicResolver *PublicResolverSession) SetPubkey(node [32]byte, x [32]byte, y [32]byte) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetPubkey(&_PublicResolver.TransactOpts, node, x, y)
|
|
}
|
|
|
|
// SetPubkey is a paid mutator transaction binding the contract method 0x29cd62ea.
|
|
//
|
|
// Solidity: function setPubkey(bytes32 node, bytes32 x, bytes32 y) returns()
|
|
func (_PublicResolver *PublicResolverTransactorSession) SetPubkey(node [32]byte, x [32]byte, y [32]byte) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetPubkey(&_PublicResolver.TransactOpts, node, x, y)
|
|
}
|
|
|
|
// SetText is a paid mutator transaction binding the contract method 0x10f13a8c.
|
|
//
|
|
// Solidity: function setText(bytes32 node, string key, string value) returns()
|
|
func (_PublicResolver *PublicResolverTransactor) SetText(opts *bind.TransactOpts, node [32]byte, key string, value string) (*types.Transaction, error) {
|
|
return _PublicResolver.contract.Transact(opts, "setText", node, key, value)
|
|
}
|
|
|
|
// SetText is a paid mutator transaction binding the contract method 0x10f13a8c.
|
|
//
|
|
// Solidity: function setText(bytes32 node, string key, string value) returns()
|
|
func (_PublicResolver *PublicResolverSession) SetText(node [32]byte, key string, value string) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetText(&_PublicResolver.TransactOpts, node, key, value)
|
|
}
|
|
|
|
// SetText is a paid mutator transaction binding the contract method 0x10f13a8c.
|
|
//
|
|
// Solidity: function setText(bytes32 node, string key, string value) returns()
|
|
func (_PublicResolver *PublicResolverTransactorSession) SetText(node [32]byte, key string, value string) (*types.Transaction, error) {
|
|
return _PublicResolver.Contract.SetText(&_PublicResolver.TransactOpts, node, key, value)
|
|
}
|
|
|
|
// PublicResolverABIChangedIterator is returned from FilterABIChanged and is used to iterate over the raw logs and unpacked data for ABIChanged events raised by the PublicResolver contract.
|
|
type PublicResolverABIChangedIterator struct {
|
|
Event *PublicResolverABIChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *PublicResolverABIChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverABIChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverABIChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *PublicResolverABIChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *PublicResolverABIChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// PublicResolverABIChanged represents a ABIChanged event raised by the PublicResolver contract.
|
|
type PublicResolverABIChanged struct {
|
|
Node [32]byte
|
|
ContentType *big.Int
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterABIChanged is a free log retrieval operation binding the contract event 0xaa121bbeef5f32f5961a2a28966e769023910fc9479059ee3495d4c1a696efe3.
|
|
//
|
|
// Solidity: event ABIChanged(bytes32 indexed node, uint256 indexed contentType)
|
|
func (_PublicResolver *PublicResolverFilterer) FilterABIChanged(opts *bind.FilterOpts, node [][32]byte, contentType []*big.Int) (*PublicResolverABIChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var contentTypeRule []interface{}
|
|
for _, contentTypeItem := range contentType {
|
|
contentTypeRule = append(contentTypeRule, contentTypeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "ABIChanged", nodeRule, contentTypeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolverABIChangedIterator{contract: _PublicResolver.contract, event: "ABIChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchABIChanged is a free log subscription operation binding the contract event 0xaa121bbeef5f32f5961a2a28966e769023910fc9479059ee3495d4c1a696efe3.
|
|
//
|
|
// Solidity: event ABIChanged(bytes32 indexed node, uint256 indexed contentType)
|
|
func (_PublicResolver *PublicResolverFilterer) WatchABIChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverABIChanged, node [][32]byte, contentType []*big.Int) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var contentTypeRule []interface{}
|
|
for _, contentTypeItem := range contentType {
|
|
contentTypeRule = append(contentTypeRule, contentTypeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "ABIChanged", nodeRule, contentTypeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(PublicResolverABIChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "ABIChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseABIChanged is a log parse operation binding the contract event 0xaa121bbeef5f32f5961a2a28966e769023910fc9479059ee3495d4c1a696efe3.
|
|
//
|
|
// Solidity: event ABIChanged(bytes32 indexed node, uint256 indexed contentType)
|
|
func (_PublicResolver *PublicResolverFilterer) ParseABIChanged(log types.Log) (*PublicResolverABIChanged, error) {
|
|
event := new(PublicResolverABIChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "ABIChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// PublicResolverAddrChangedIterator is returned from FilterAddrChanged and is used to iterate over the raw logs and unpacked data for AddrChanged events raised by the PublicResolver contract.
|
|
type PublicResolverAddrChangedIterator struct {
|
|
Event *PublicResolverAddrChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *PublicResolverAddrChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverAddrChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverAddrChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *PublicResolverAddrChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *PublicResolverAddrChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// PublicResolverAddrChanged represents a AddrChanged event raised by the PublicResolver contract.
|
|
type PublicResolverAddrChanged struct {
|
|
Node [32]byte
|
|
A common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterAddrChanged is a free log retrieval operation binding the contract event 0x52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2.
|
|
//
|
|
// Solidity: event AddrChanged(bytes32 indexed node, address a)
|
|
func (_PublicResolver *PublicResolverFilterer) FilterAddrChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverAddrChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "AddrChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolverAddrChangedIterator{contract: _PublicResolver.contract, event: "AddrChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchAddrChanged is a free log subscription operation binding the contract event 0x52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2.
|
|
//
|
|
// Solidity: event AddrChanged(bytes32 indexed node, address a)
|
|
func (_PublicResolver *PublicResolverFilterer) WatchAddrChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverAddrChanged, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "AddrChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(PublicResolverAddrChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "AddrChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseAddrChanged is a log parse operation binding the contract event 0x52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2.
|
|
//
|
|
// Solidity: event AddrChanged(bytes32 indexed node, address a)
|
|
func (_PublicResolver *PublicResolverFilterer) ParseAddrChanged(log types.Log) (*PublicResolverAddrChanged, error) {
|
|
event := new(PublicResolverAddrChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "AddrChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// PublicResolverAddressChangedIterator is returned from FilterAddressChanged and is used to iterate over the raw logs and unpacked data for AddressChanged events raised by the PublicResolver contract.
|
|
type PublicResolverAddressChangedIterator struct {
|
|
Event *PublicResolverAddressChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *PublicResolverAddressChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverAddressChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverAddressChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *PublicResolverAddressChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *PublicResolverAddressChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// PublicResolverAddressChanged represents a AddressChanged event raised by the PublicResolver contract.
|
|
type PublicResolverAddressChanged struct {
|
|
Node [32]byte
|
|
CoinType *big.Int
|
|
NewAddress []byte
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterAddressChanged is a free log retrieval operation binding the contract event 0x65412581168e88a1e60c6459d7f44ae83ad0832e670826c05a4e2476b57af752.
|
|
//
|
|
// Solidity: event AddressChanged(bytes32 indexed node, uint256 coinType, bytes newAddress)
|
|
func (_PublicResolver *PublicResolverFilterer) FilterAddressChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverAddressChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "AddressChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolverAddressChangedIterator{contract: _PublicResolver.contract, event: "AddressChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchAddressChanged is a free log subscription operation binding the contract event 0x65412581168e88a1e60c6459d7f44ae83ad0832e670826c05a4e2476b57af752.
|
|
//
|
|
// Solidity: event AddressChanged(bytes32 indexed node, uint256 coinType, bytes newAddress)
|
|
func (_PublicResolver *PublicResolverFilterer) WatchAddressChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverAddressChanged, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "AddressChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(PublicResolverAddressChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "AddressChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseAddressChanged is a log parse operation binding the contract event 0x65412581168e88a1e60c6459d7f44ae83ad0832e670826c05a4e2476b57af752.
|
|
//
|
|
// Solidity: event AddressChanged(bytes32 indexed node, uint256 coinType, bytes newAddress)
|
|
func (_PublicResolver *PublicResolverFilterer) ParseAddressChanged(log types.Log) (*PublicResolverAddressChanged, error) {
|
|
event := new(PublicResolverAddressChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "AddressChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// PublicResolverAuthorisationChangedIterator is returned from FilterAuthorisationChanged and is used to iterate over the raw logs and unpacked data for AuthorisationChanged events raised by the PublicResolver contract.
|
|
type PublicResolverAuthorisationChangedIterator struct {
|
|
Event *PublicResolverAuthorisationChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *PublicResolverAuthorisationChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverAuthorisationChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverAuthorisationChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *PublicResolverAuthorisationChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *PublicResolverAuthorisationChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// PublicResolverAuthorisationChanged represents a AuthorisationChanged event raised by the PublicResolver contract.
|
|
type PublicResolverAuthorisationChanged struct {
|
|
Node [32]byte
|
|
Owner common.Address
|
|
Target common.Address
|
|
IsAuthorised bool
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterAuthorisationChanged is a free log retrieval operation binding the contract event 0xe1c5610a6e0cbe10764ecd182adcef1ec338dc4e199c99c32ce98f38e12791df.
|
|
//
|
|
// Solidity: event AuthorisationChanged(bytes32 indexed node, address indexed owner, address indexed target, bool isAuthorised)
|
|
func (_PublicResolver *PublicResolverFilterer) FilterAuthorisationChanged(opts *bind.FilterOpts, node [][32]byte, owner []common.Address, target []common.Address) (*PublicResolverAuthorisationChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var targetRule []interface{}
|
|
for _, targetItem := range target {
|
|
targetRule = append(targetRule, targetItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "AuthorisationChanged", nodeRule, ownerRule, targetRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolverAuthorisationChangedIterator{contract: _PublicResolver.contract, event: "AuthorisationChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchAuthorisationChanged is a free log subscription operation binding the contract event 0xe1c5610a6e0cbe10764ecd182adcef1ec338dc4e199c99c32ce98f38e12791df.
|
|
//
|
|
// Solidity: event AuthorisationChanged(bytes32 indexed node, address indexed owner, address indexed target, bool isAuthorised)
|
|
func (_PublicResolver *PublicResolverFilterer) WatchAuthorisationChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverAuthorisationChanged, node [][32]byte, owner []common.Address, target []common.Address) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var ownerRule []interface{}
|
|
for _, ownerItem := range owner {
|
|
ownerRule = append(ownerRule, ownerItem)
|
|
}
|
|
var targetRule []interface{}
|
|
for _, targetItem := range target {
|
|
targetRule = append(targetRule, targetItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "AuthorisationChanged", nodeRule, ownerRule, targetRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(PublicResolverAuthorisationChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "AuthorisationChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseAuthorisationChanged is a log parse operation binding the contract event 0xe1c5610a6e0cbe10764ecd182adcef1ec338dc4e199c99c32ce98f38e12791df.
|
|
//
|
|
// Solidity: event AuthorisationChanged(bytes32 indexed node, address indexed owner, address indexed target, bool isAuthorised)
|
|
func (_PublicResolver *PublicResolverFilterer) ParseAuthorisationChanged(log types.Log) (*PublicResolverAuthorisationChanged, error) {
|
|
event := new(PublicResolverAuthorisationChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "AuthorisationChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// PublicResolverContenthashChangedIterator is returned from FilterContenthashChanged and is used to iterate over the raw logs and unpacked data for ContenthashChanged events raised by the PublicResolver contract.
|
|
type PublicResolverContenthashChangedIterator struct {
|
|
Event *PublicResolverContenthashChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *PublicResolverContenthashChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverContenthashChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverContenthashChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *PublicResolverContenthashChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *PublicResolverContenthashChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// PublicResolverContenthashChanged represents a ContenthashChanged event raised by the PublicResolver contract.
|
|
type PublicResolverContenthashChanged struct {
|
|
Node [32]byte
|
|
Hash []byte
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterContenthashChanged is a free log retrieval operation binding the contract event 0xe379c1624ed7e714cc0937528a32359d69d5281337765313dba4e081b72d7578.
|
|
//
|
|
// Solidity: event ContenthashChanged(bytes32 indexed node, bytes hash)
|
|
func (_PublicResolver *PublicResolverFilterer) FilterContenthashChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverContenthashChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "ContenthashChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolverContenthashChangedIterator{contract: _PublicResolver.contract, event: "ContenthashChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchContenthashChanged is a free log subscription operation binding the contract event 0xe379c1624ed7e714cc0937528a32359d69d5281337765313dba4e081b72d7578.
|
|
//
|
|
// Solidity: event ContenthashChanged(bytes32 indexed node, bytes hash)
|
|
func (_PublicResolver *PublicResolverFilterer) WatchContenthashChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverContenthashChanged, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "ContenthashChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(PublicResolverContenthashChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "ContenthashChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseContenthashChanged is a log parse operation binding the contract event 0xe379c1624ed7e714cc0937528a32359d69d5281337765313dba4e081b72d7578.
|
|
//
|
|
// Solidity: event ContenthashChanged(bytes32 indexed node, bytes hash)
|
|
func (_PublicResolver *PublicResolverFilterer) ParseContenthashChanged(log types.Log) (*PublicResolverContenthashChanged, error) {
|
|
event := new(PublicResolverContenthashChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "ContenthashChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// PublicResolverDNSRecordChangedIterator is returned from FilterDNSRecordChanged and is used to iterate over the raw logs and unpacked data for DNSRecordChanged events raised by the PublicResolver contract.
|
|
type PublicResolverDNSRecordChangedIterator struct {
|
|
Event *PublicResolverDNSRecordChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *PublicResolverDNSRecordChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverDNSRecordChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverDNSRecordChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *PublicResolverDNSRecordChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *PublicResolverDNSRecordChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// PublicResolverDNSRecordChanged represents a DNSRecordChanged event raised by the PublicResolver contract.
|
|
type PublicResolverDNSRecordChanged struct {
|
|
Node [32]byte
|
|
Name []byte
|
|
Resource uint16
|
|
Record []byte
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterDNSRecordChanged is a free log retrieval operation binding the contract event 0x52a608b3303a48862d07a73d82fa221318c0027fbbcfb1b2329bface3f19ff2b.
|
|
//
|
|
// Solidity: event DNSRecordChanged(bytes32 indexed node, bytes name, uint16 resource, bytes record)
|
|
func (_PublicResolver *PublicResolverFilterer) FilterDNSRecordChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverDNSRecordChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "DNSRecordChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolverDNSRecordChangedIterator{contract: _PublicResolver.contract, event: "DNSRecordChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchDNSRecordChanged is a free log subscription operation binding the contract event 0x52a608b3303a48862d07a73d82fa221318c0027fbbcfb1b2329bface3f19ff2b.
|
|
//
|
|
// Solidity: event DNSRecordChanged(bytes32 indexed node, bytes name, uint16 resource, bytes record)
|
|
func (_PublicResolver *PublicResolverFilterer) WatchDNSRecordChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverDNSRecordChanged, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "DNSRecordChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(PublicResolverDNSRecordChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "DNSRecordChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseDNSRecordChanged is a log parse operation binding the contract event 0x52a608b3303a48862d07a73d82fa221318c0027fbbcfb1b2329bface3f19ff2b.
|
|
//
|
|
// Solidity: event DNSRecordChanged(bytes32 indexed node, bytes name, uint16 resource, bytes record)
|
|
func (_PublicResolver *PublicResolverFilterer) ParseDNSRecordChanged(log types.Log) (*PublicResolverDNSRecordChanged, error) {
|
|
event := new(PublicResolverDNSRecordChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "DNSRecordChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// PublicResolverDNSRecordDeletedIterator is returned from FilterDNSRecordDeleted and is used to iterate over the raw logs and unpacked data for DNSRecordDeleted events raised by the PublicResolver contract.
|
|
type PublicResolverDNSRecordDeletedIterator struct {
|
|
Event *PublicResolverDNSRecordDeleted // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *PublicResolverDNSRecordDeletedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverDNSRecordDeleted)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverDNSRecordDeleted)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *PublicResolverDNSRecordDeletedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *PublicResolverDNSRecordDeletedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// PublicResolverDNSRecordDeleted represents a DNSRecordDeleted event raised by the PublicResolver contract.
|
|
type PublicResolverDNSRecordDeleted struct {
|
|
Node [32]byte
|
|
Name []byte
|
|
Resource uint16
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterDNSRecordDeleted is a free log retrieval operation binding the contract event 0x03528ed0c2a3ebc993b12ce3c16bb382f9c7d88ef7d8a1bf290eaf35955a1207.
|
|
//
|
|
// Solidity: event DNSRecordDeleted(bytes32 indexed node, bytes name, uint16 resource)
|
|
func (_PublicResolver *PublicResolverFilterer) FilterDNSRecordDeleted(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverDNSRecordDeletedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "DNSRecordDeleted", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolverDNSRecordDeletedIterator{contract: _PublicResolver.contract, event: "DNSRecordDeleted", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchDNSRecordDeleted is a free log subscription operation binding the contract event 0x03528ed0c2a3ebc993b12ce3c16bb382f9c7d88ef7d8a1bf290eaf35955a1207.
|
|
//
|
|
// Solidity: event DNSRecordDeleted(bytes32 indexed node, bytes name, uint16 resource)
|
|
func (_PublicResolver *PublicResolverFilterer) WatchDNSRecordDeleted(opts *bind.WatchOpts, sink chan<- *PublicResolverDNSRecordDeleted, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "DNSRecordDeleted", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(PublicResolverDNSRecordDeleted)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "DNSRecordDeleted", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseDNSRecordDeleted is a log parse operation binding the contract event 0x03528ed0c2a3ebc993b12ce3c16bb382f9c7d88ef7d8a1bf290eaf35955a1207.
|
|
//
|
|
// Solidity: event DNSRecordDeleted(bytes32 indexed node, bytes name, uint16 resource)
|
|
func (_PublicResolver *PublicResolverFilterer) ParseDNSRecordDeleted(log types.Log) (*PublicResolverDNSRecordDeleted, error) {
|
|
event := new(PublicResolverDNSRecordDeleted)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "DNSRecordDeleted", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// PublicResolverDNSZoneClearedIterator is returned from FilterDNSZoneCleared and is used to iterate over the raw logs and unpacked data for DNSZoneCleared events raised by the PublicResolver contract.
|
|
type PublicResolverDNSZoneClearedIterator struct {
|
|
Event *PublicResolverDNSZoneCleared // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *PublicResolverDNSZoneClearedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverDNSZoneCleared)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverDNSZoneCleared)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *PublicResolverDNSZoneClearedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *PublicResolverDNSZoneClearedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// PublicResolverDNSZoneCleared represents a DNSZoneCleared event raised by the PublicResolver contract.
|
|
type PublicResolverDNSZoneCleared struct {
|
|
Node [32]byte
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterDNSZoneCleared is a free log retrieval operation binding the contract event 0xb757169b8492ca2f1c6619d9d76ce22803035c3b1d5f6930dffe7b127c1a1983.
|
|
//
|
|
// Solidity: event DNSZoneCleared(bytes32 indexed node)
|
|
func (_PublicResolver *PublicResolverFilterer) FilterDNSZoneCleared(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverDNSZoneClearedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "DNSZoneCleared", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolverDNSZoneClearedIterator{contract: _PublicResolver.contract, event: "DNSZoneCleared", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchDNSZoneCleared is a free log subscription operation binding the contract event 0xb757169b8492ca2f1c6619d9d76ce22803035c3b1d5f6930dffe7b127c1a1983.
|
|
//
|
|
// Solidity: event DNSZoneCleared(bytes32 indexed node)
|
|
func (_PublicResolver *PublicResolverFilterer) WatchDNSZoneCleared(opts *bind.WatchOpts, sink chan<- *PublicResolverDNSZoneCleared, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "DNSZoneCleared", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(PublicResolverDNSZoneCleared)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "DNSZoneCleared", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseDNSZoneCleared is a log parse operation binding the contract event 0xb757169b8492ca2f1c6619d9d76ce22803035c3b1d5f6930dffe7b127c1a1983.
|
|
//
|
|
// Solidity: event DNSZoneCleared(bytes32 indexed node)
|
|
func (_PublicResolver *PublicResolverFilterer) ParseDNSZoneCleared(log types.Log) (*PublicResolverDNSZoneCleared, error) {
|
|
event := new(PublicResolverDNSZoneCleared)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "DNSZoneCleared", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// PublicResolverInterfaceChangedIterator is returned from FilterInterfaceChanged and is used to iterate over the raw logs and unpacked data for InterfaceChanged events raised by the PublicResolver contract.
|
|
type PublicResolverInterfaceChangedIterator struct {
|
|
Event *PublicResolverInterfaceChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *PublicResolverInterfaceChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverInterfaceChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverInterfaceChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *PublicResolverInterfaceChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *PublicResolverInterfaceChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// PublicResolverInterfaceChanged represents a InterfaceChanged event raised by the PublicResolver contract.
|
|
type PublicResolverInterfaceChanged struct {
|
|
Node [32]byte
|
|
InterfaceID [4]byte
|
|
Implementer common.Address
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterInterfaceChanged is a free log retrieval operation binding the contract event 0x7c69f06bea0bdef565b709e93a147836b0063ba2dd89f02d0b7e8d931e6a6daa.
|
|
//
|
|
// Solidity: event InterfaceChanged(bytes32 indexed node, bytes4 indexed interfaceID, address implementer)
|
|
func (_PublicResolver *PublicResolverFilterer) FilterInterfaceChanged(opts *bind.FilterOpts, node [][32]byte, interfaceID [][4]byte) (*PublicResolverInterfaceChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var interfaceIDRule []interface{}
|
|
for _, interfaceIDItem := range interfaceID {
|
|
interfaceIDRule = append(interfaceIDRule, interfaceIDItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "InterfaceChanged", nodeRule, interfaceIDRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolverInterfaceChangedIterator{contract: _PublicResolver.contract, event: "InterfaceChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchInterfaceChanged is a free log subscription operation binding the contract event 0x7c69f06bea0bdef565b709e93a147836b0063ba2dd89f02d0b7e8d931e6a6daa.
|
|
//
|
|
// Solidity: event InterfaceChanged(bytes32 indexed node, bytes4 indexed interfaceID, address implementer)
|
|
func (_PublicResolver *PublicResolverFilterer) WatchInterfaceChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverInterfaceChanged, node [][32]byte, interfaceID [][4]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var interfaceIDRule []interface{}
|
|
for _, interfaceIDItem := range interfaceID {
|
|
interfaceIDRule = append(interfaceIDRule, interfaceIDItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "InterfaceChanged", nodeRule, interfaceIDRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(PublicResolverInterfaceChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "InterfaceChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseInterfaceChanged is a log parse operation binding the contract event 0x7c69f06bea0bdef565b709e93a147836b0063ba2dd89f02d0b7e8d931e6a6daa.
|
|
//
|
|
// Solidity: event InterfaceChanged(bytes32 indexed node, bytes4 indexed interfaceID, address implementer)
|
|
func (_PublicResolver *PublicResolverFilterer) ParseInterfaceChanged(log types.Log) (*PublicResolverInterfaceChanged, error) {
|
|
event := new(PublicResolverInterfaceChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "InterfaceChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// PublicResolverNameChangedIterator is returned from FilterNameChanged and is used to iterate over the raw logs and unpacked data for NameChanged events raised by the PublicResolver contract.
|
|
type PublicResolverNameChangedIterator struct {
|
|
Event *PublicResolverNameChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *PublicResolverNameChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverNameChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverNameChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *PublicResolverNameChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *PublicResolverNameChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// PublicResolverNameChanged represents a NameChanged event raised by the PublicResolver contract.
|
|
type PublicResolverNameChanged struct {
|
|
Node [32]byte
|
|
Name string
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterNameChanged is a free log retrieval operation binding the contract event 0xb7d29e911041e8d9b843369e890bcb72c9388692ba48b65ac54e7214c4c348f7.
|
|
//
|
|
// Solidity: event NameChanged(bytes32 indexed node, string name)
|
|
func (_PublicResolver *PublicResolverFilterer) FilterNameChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverNameChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "NameChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolverNameChangedIterator{contract: _PublicResolver.contract, event: "NameChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchNameChanged is a free log subscription operation binding the contract event 0xb7d29e911041e8d9b843369e890bcb72c9388692ba48b65ac54e7214c4c348f7.
|
|
//
|
|
// Solidity: event NameChanged(bytes32 indexed node, string name)
|
|
func (_PublicResolver *PublicResolverFilterer) WatchNameChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverNameChanged, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "NameChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(PublicResolverNameChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "NameChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseNameChanged is a log parse operation binding the contract event 0xb7d29e911041e8d9b843369e890bcb72c9388692ba48b65ac54e7214c4c348f7.
|
|
//
|
|
// Solidity: event NameChanged(bytes32 indexed node, string name)
|
|
func (_PublicResolver *PublicResolverFilterer) ParseNameChanged(log types.Log) (*PublicResolverNameChanged, error) {
|
|
event := new(PublicResolverNameChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "NameChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// PublicResolverPubkeyChangedIterator is returned from FilterPubkeyChanged and is used to iterate over the raw logs and unpacked data for PubkeyChanged events raised by the PublicResolver contract.
|
|
type PublicResolverPubkeyChangedIterator struct {
|
|
Event *PublicResolverPubkeyChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *PublicResolverPubkeyChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverPubkeyChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverPubkeyChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *PublicResolverPubkeyChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *PublicResolverPubkeyChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// PublicResolverPubkeyChanged represents a PubkeyChanged event raised by the PublicResolver contract.
|
|
type PublicResolverPubkeyChanged struct {
|
|
Node [32]byte
|
|
X [32]byte
|
|
Y [32]byte
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterPubkeyChanged is a free log retrieval operation binding the contract event 0x1d6f5e03d3f63eb58751986629a5439baee5079ff04f345becb66e23eb154e46.
|
|
//
|
|
// Solidity: event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y)
|
|
func (_PublicResolver *PublicResolverFilterer) FilterPubkeyChanged(opts *bind.FilterOpts, node [][32]byte) (*PublicResolverPubkeyChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "PubkeyChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolverPubkeyChangedIterator{contract: _PublicResolver.contract, event: "PubkeyChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchPubkeyChanged is a free log subscription operation binding the contract event 0x1d6f5e03d3f63eb58751986629a5439baee5079ff04f345becb66e23eb154e46.
|
|
//
|
|
// Solidity: event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y)
|
|
func (_PublicResolver *PublicResolverFilterer) WatchPubkeyChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverPubkeyChanged, node [][32]byte) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "PubkeyChanged", nodeRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(PublicResolverPubkeyChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "PubkeyChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParsePubkeyChanged is a log parse operation binding the contract event 0x1d6f5e03d3f63eb58751986629a5439baee5079ff04f345becb66e23eb154e46.
|
|
//
|
|
// Solidity: event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y)
|
|
func (_PublicResolver *PublicResolverFilterer) ParsePubkeyChanged(log types.Log) (*PublicResolverPubkeyChanged, error) {
|
|
event := new(PublicResolverPubkeyChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "PubkeyChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// PublicResolverTextChangedIterator is returned from FilterTextChanged and is used to iterate over the raw logs and unpacked data for TextChanged events raised by the PublicResolver contract.
|
|
type PublicResolverTextChangedIterator struct {
|
|
Event *PublicResolverTextChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *PublicResolverTextChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverTextChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(PublicResolverTextChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *PublicResolverTextChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *PublicResolverTextChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// PublicResolverTextChanged represents a TextChanged event raised by the PublicResolver contract.
|
|
type PublicResolverTextChanged struct {
|
|
Node [32]byte
|
|
IndexedKey common.Hash
|
|
Key string
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterTextChanged is a free log retrieval operation binding the contract event 0xd8c9334b1a9c2f9da342a0a2b32629c1a229b6445dad78947f674b44444a7550.
|
|
//
|
|
// Solidity: event TextChanged(bytes32 indexed node, string indexed indexedKey, string key)
|
|
func (_PublicResolver *PublicResolverFilterer) FilterTextChanged(opts *bind.FilterOpts, node [][32]byte, indexedKey []string) (*PublicResolverTextChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var indexedKeyRule []interface{}
|
|
for _, indexedKeyItem := range indexedKey {
|
|
indexedKeyRule = append(indexedKeyRule, indexedKeyItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.FilterLogs(opts, "TextChanged", nodeRule, indexedKeyRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &PublicResolverTextChangedIterator{contract: _PublicResolver.contract, event: "TextChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchTextChanged is a free log subscription operation binding the contract event 0xd8c9334b1a9c2f9da342a0a2b32629c1a229b6445dad78947f674b44444a7550.
|
|
//
|
|
// Solidity: event TextChanged(bytes32 indexed node, string indexed indexedKey, string key)
|
|
func (_PublicResolver *PublicResolverFilterer) WatchTextChanged(opts *bind.WatchOpts, sink chan<- *PublicResolverTextChanged, node [][32]byte, indexedKey []string) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var indexedKeyRule []interface{}
|
|
for _, indexedKeyItem := range indexedKey {
|
|
indexedKeyRule = append(indexedKeyRule, indexedKeyItem)
|
|
}
|
|
|
|
logs, sub, err := _PublicResolver.contract.WatchLogs(opts, "TextChanged", nodeRule, indexedKeyRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(PublicResolverTextChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "TextChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseTextChanged is a log parse operation binding the contract event 0xd8c9334b1a9c2f9da342a0a2b32629c1a229b6445dad78947f674b44444a7550.
|
|
//
|
|
// Solidity: event TextChanged(bytes32 indexed node, string indexed indexedKey, string key)
|
|
func (_PublicResolver *PublicResolverFilterer) ParseTextChanged(log types.Log) (*PublicResolverTextChanged, error) {
|
|
event := new(PublicResolverTextChanged)
|
|
if err := _PublicResolver.contract.UnpackLog(event, "TextChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|
|
|
|
// ResolverBaseABI is the input ABI used to generate the binding from.
|
|
const ResolverBaseABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"}]"
|
|
|
|
// ResolverBaseFuncSigs maps the 4-byte function signature to its string representation.
|
|
var ResolverBaseFuncSigs = map[string]string{
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
}
|
|
|
|
// ResolverBase is an auto generated Go binding around an Ethereum contract.
|
|
type ResolverBase struct {
|
|
ResolverBaseCaller // Read-only binding to the contract
|
|
ResolverBaseTransactor // Write-only binding to the contract
|
|
ResolverBaseFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// ResolverBaseCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type ResolverBaseCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ResolverBaseTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type ResolverBaseTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ResolverBaseFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type ResolverBaseFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// ResolverBaseSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type ResolverBaseSession struct {
|
|
Contract *ResolverBase // 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
|
|
}
|
|
|
|
// ResolverBaseCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type ResolverBaseCallerSession struct {
|
|
Contract *ResolverBaseCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// ResolverBaseTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type ResolverBaseTransactorSession struct {
|
|
Contract *ResolverBaseTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// ResolverBaseRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type ResolverBaseRaw struct {
|
|
Contract *ResolverBase // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// ResolverBaseCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type ResolverBaseCallerRaw struct {
|
|
Contract *ResolverBaseCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// ResolverBaseTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type ResolverBaseTransactorRaw struct {
|
|
Contract *ResolverBaseTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewResolverBase creates a new instance of ResolverBase, bound to a specific deployed contract.
|
|
func NewResolverBase(address common.Address, backend bind.ContractBackend) (*ResolverBase, error) {
|
|
contract, err := bindResolverBase(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ResolverBase{ResolverBaseCaller: ResolverBaseCaller{contract: contract}, ResolverBaseTransactor: ResolverBaseTransactor{contract: contract}, ResolverBaseFilterer: ResolverBaseFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewResolverBaseCaller creates a new read-only instance of ResolverBase, bound to a specific deployed contract.
|
|
func NewResolverBaseCaller(address common.Address, caller bind.ContractCaller) (*ResolverBaseCaller, error) {
|
|
contract, err := bindResolverBase(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ResolverBaseCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewResolverBaseTransactor creates a new write-only instance of ResolverBase, bound to a specific deployed contract.
|
|
func NewResolverBaseTransactor(address common.Address, transactor bind.ContractTransactor) (*ResolverBaseTransactor, error) {
|
|
contract, err := bindResolverBase(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ResolverBaseTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewResolverBaseFilterer creates a new log filterer instance of ResolverBase, bound to a specific deployed contract.
|
|
func NewResolverBaseFilterer(address common.Address, filterer bind.ContractFilterer) (*ResolverBaseFilterer, error) {
|
|
contract, err := bindResolverBase(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &ResolverBaseFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindResolverBase binds a generic wrapper to an already deployed contract.
|
|
func bindResolverBase(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(ResolverBaseABI))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
|
|
}
|
|
|
|
// 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 (_ResolverBase *ResolverBaseRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ResolverBase.Contract.ResolverBaseCaller.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_ResolverBase *ResolverBaseRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ResolverBase.Contract.ResolverBaseTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ResolverBase *ResolverBaseRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ResolverBase.Contract.ResolverBaseTransactor.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// 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 (_ResolverBase *ResolverBaseCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _ResolverBase.Contract.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_ResolverBase *ResolverBaseTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _ResolverBase.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_ResolverBase *ResolverBaseTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _ResolverBase.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_ResolverBase *ResolverBaseCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _ResolverBase.contract.Call(opts, &out, "supportsInterface", interfaceID)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_ResolverBase *ResolverBaseSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _ResolverBase.Contract.SupportsInterface(&_ResolverBase.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_ResolverBase *ResolverBaseCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _ResolverBase.Contract.SupportsInterface(&_ResolverBase.CallOpts, interfaceID)
|
|
}
|
|
|
|
// TextResolverABI is the input ABI used to generate the binding from.
|
|
const TextResolverABI = "[{\"constant\":true,\"inputs\":[{\"name\":\"interfaceID\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"key\",\"type\":\"string\"},{\"name\":\"value\",\"type\":\"string\"}],\"name\":\"setText\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"node\",\"type\":\"bytes32\"},{\"name\":\"key\",\"type\":\"string\"}],\"name\":\"text\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"node\",\"type\":\"bytes32\"},{\"indexed\":true,\"name\":\"indexedKey\",\"type\":\"string\"},{\"indexed\":false,\"name\":\"key\",\"type\":\"string\"}],\"name\":\"TextChanged\",\"type\":\"event\"}]"
|
|
|
|
// TextResolverFuncSigs maps the 4-byte function signature to its string representation.
|
|
var TextResolverFuncSigs = map[string]string{
|
|
"10f13a8c": "setText(bytes32,string,string)",
|
|
"01ffc9a7": "supportsInterface(bytes4)",
|
|
"59d1d43c": "text(bytes32,string)",
|
|
}
|
|
|
|
// TextResolver is an auto generated Go binding around an Ethereum contract.
|
|
type TextResolver struct {
|
|
TextResolverCaller // Read-only binding to the contract
|
|
TextResolverTransactor // Write-only binding to the contract
|
|
TextResolverFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// TextResolverCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type TextResolverCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// TextResolverTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type TextResolverTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// TextResolverFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type TextResolverFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// TextResolverSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type TextResolverSession struct {
|
|
Contract *TextResolver // 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
|
|
}
|
|
|
|
// TextResolverCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type TextResolverCallerSession struct {
|
|
Contract *TextResolverCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// TextResolverTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type TextResolverTransactorSession struct {
|
|
Contract *TextResolverTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// TextResolverRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type TextResolverRaw struct {
|
|
Contract *TextResolver // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// TextResolverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type TextResolverCallerRaw struct {
|
|
Contract *TextResolverCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// TextResolverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type TextResolverTransactorRaw struct {
|
|
Contract *TextResolverTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewTextResolver creates a new instance of TextResolver, bound to a specific deployed contract.
|
|
func NewTextResolver(address common.Address, backend bind.ContractBackend) (*TextResolver, error) {
|
|
contract, err := bindTextResolver(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TextResolver{TextResolverCaller: TextResolverCaller{contract: contract}, TextResolverTransactor: TextResolverTransactor{contract: contract}, TextResolverFilterer: TextResolverFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewTextResolverCaller creates a new read-only instance of TextResolver, bound to a specific deployed contract.
|
|
func NewTextResolverCaller(address common.Address, caller bind.ContractCaller) (*TextResolverCaller, error) {
|
|
contract, err := bindTextResolver(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TextResolverCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewTextResolverTransactor creates a new write-only instance of TextResolver, bound to a specific deployed contract.
|
|
func NewTextResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*TextResolverTransactor, error) {
|
|
contract, err := bindTextResolver(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TextResolverTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewTextResolverFilterer creates a new log filterer instance of TextResolver, bound to a specific deployed contract.
|
|
func NewTextResolverFilterer(address common.Address, filterer bind.ContractFilterer) (*TextResolverFilterer, error) {
|
|
contract, err := bindTextResolver(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TextResolverFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindTextResolver binds a generic wrapper to an already deployed contract.
|
|
func bindTextResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(TextResolverABI))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
|
|
}
|
|
|
|
// 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 (_TextResolver *TextResolverRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _TextResolver.Contract.TextResolverCaller.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_TextResolver *TextResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _TextResolver.Contract.TextResolverTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_TextResolver *TextResolverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _TextResolver.Contract.TextResolverTransactor.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// 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 (_TextResolver *TextResolverCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _TextResolver.Contract.contract.Call(opts, result, method, params...)
|
|
}
|
|
|
|
// Transfer initiates a plain transaction to move funds to the contract, calling
|
|
// its default method if one is available.
|
|
func (_TextResolver *TextResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
|
|
return _TextResolver.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_TextResolver *TextResolverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
|
|
return _TextResolver.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_TextResolver *TextResolverCaller) SupportsInterface(opts *bind.CallOpts, interfaceID [4]byte) (bool, error) {
|
|
var out []interface{}
|
|
err := _TextResolver.contract.Call(opts, &out, "supportsInterface", interfaceID)
|
|
|
|
if err != nil {
|
|
return *new(bool), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_TextResolver *TextResolverSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _TextResolver.Contract.SupportsInterface(&_TextResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
|
|
//
|
|
// Solidity: function supportsInterface(bytes4 interfaceID) pure returns(bool)
|
|
func (_TextResolver *TextResolverCallerSession) SupportsInterface(interfaceID [4]byte) (bool, error) {
|
|
return _TextResolver.Contract.SupportsInterface(&_TextResolver.CallOpts, interfaceID)
|
|
}
|
|
|
|
// Text is a free data retrieval call binding the contract method 0x59d1d43c.
|
|
//
|
|
// Solidity: function text(bytes32 node, string key) view returns(string)
|
|
func (_TextResolver *TextResolverCaller) Text(opts *bind.CallOpts, node [32]byte, key string) (string, error) {
|
|
var out []interface{}
|
|
err := _TextResolver.contract.Call(opts, &out, "text", node, key)
|
|
|
|
if err != nil {
|
|
return *new(string), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(string)).(*string)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Text is a free data retrieval call binding the contract method 0x59d1d43c.
|
|
//
|
|
// Solidity: function text(bytes32 node, string key) view returns(string)
|
|
func (_TextResolver *TextResolverSession) Text(node [32]byte, key string) (string, error) {
|
|
return _TextResolver.Contract.Text(&_TextResolver.CallOpts, node, key)
|
|
}
|
|
|
|
// Text is a free data retrieval call binding the contract method 0x59d1d43c.
|
|
//
|
|
// Solidity: function text(bytes32 node, string key) view returns(string)
|
|
func (_TextResolver *TextResolverCallerSession) Text(node [32]byte, key string) (string, error) {
|
|
return _TextResolver.Contract.Text(&_TextResolver.CallOpts, node, key)
|
|
}
|
|
|
|
// SetText is a paid mutator transaction binding the contract method 0x10f13a8c.
|
|
//
|
|
// Solidity: function setText(bytes32 node, string key, string value) returns()
|
|
func (_TextResolver *TextResolverTransactor) SetText(opts *bind.TransactOpts, node [32]byte, key string, value string) (*types.Transaction, error) {
|
|
return _TextResolver.contract.Transact(opts, "setText", node, key, value)
|
|
}
|
|
|
|
// SetText is a paid mutator transaction binding the contract method 0x10f13a8c.
|
|
//
|
|
// Solidity: function setText(bytes32 node, string key, string value) returns()
|
|
func (_TextResolver *TextResolverSession) SetText(node [32]byte, key string, value string) (*types.Transaction, error) {
|
|
return _TextResolver.Contract.SetText(&_TextResolver.TransactOpts, node, key, value)
|
|
}
|
|
|
|
// SetText is a paid mutator transaction binding the contract method 0x10f13a8c.
|
|
//
|
|
// Solidity: function setText(bytes32 node, string key, string value) returns()
|
|
func (_TextResolver *TextResolverTransactorSession) SetText(node [32]byte, key string, value string) (*types.Transaction, error) {
|
|
return _TextResolver.Contract.SetText(&_TextResolver.TransactOpts, node, key, value)
|
|
}
|
|
|
|
// TextResolverTextChangedIterator is returned from FilterTextChanged and is used to iterate over the raw logs and unpacked data for TextChanged events raised by the TextResolver contract.
|
|
type TextResolverTextChangedIterator struct {
|
|
Event *TextResolverTextChanged // Event containing the contract specifics and raw log
|
|
|
|
contract *bind.BoundContract // Generic contract to use for unpacking event data
|
|
event string // Event name to use for unpacking event data
|
|
|
|
logs chan types.Log // Log channel receiving the found contract events
|
|
sub ethereum.Subscription // Subscription for errors, completion and termination
|
|
done bool // Whether the subscription completed delivering logs
|
|
fail error // Occurred error to stop iteration
|
|
}
|
|
|
|
// 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.
|
|
func (it *TextResolverTextChangedIterator) Next() bool {
|
|
// If the iterator failed, stop iterating
|
|
if it.fail != nil {
|
|
return false
|
|
}
|
|
// If the iterator completed, deliver directly whatever's available
|
|
if it.done {
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(TextResolverTextChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
// Iterator still in progress, wait for either a data or an error event
|
|
select {
|
|
case log := <-it.logs:
|
|
it.Event = new(TextResolverTextChanged)
|
|
if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
|
|
it.fail = err
|
|
return false
|
|
}
|
|
it.Event.Raw = log
|
|
return true
|
|
|
|
case err := <-it.sub.Err():
|
|
it.done = true
|
|
it.fail = err
|
|
return it.Next()
|
|
}
|
|
}
|
|
|
|
// Error returns any retrieval or parsing error occurred during filtering.
|
|
func (it *TextResolverTextChangedIterator) Error() error {
|
|
return it.fail
|
|
}
|
|
|
|
// Close terminates the iteration process, releasing any pending underlying
|
|
// resources.
|
|
func (it *TextResolverTextChangedIterator) Close() error {
|
|
it.sub.Unsubscribe()
|
|
return nil
|
|
}
|
|
|
|
// TextResolverTextChanged represents a TextChanged event raised by the TextResolver contract.
|
|
type TextResolverTextChanged struct {
|
|
Node [32]byte
|
|
IndexedKey common.Hash
|
|
Key string
|
|
Raw types.Log // Blockchain specific contextual infos
|
|
}
|
|
|
|
// FilterTextChanged is a free log retrieval operation binding the contract event 0xd8c9334b1a9c2f9da342a0a2b32629c1a229b6445dad78947f674b44444a7550.
|
|
//
|
|
// Solidity: event TextChanged(bytes32 indexed node, string indexed indexedKey, string key)
|
|
func (_TextResolver *TextResolverFilterer) FilterTextChanged(opts *bind.FilterOpts, node [][32]byte, indexedKey []string) (*TextResolverTextChangedIterator, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var indexedKeyRule []interface{}
|
|
for _, indexedKeyItem := range indexedKey {
|
|
indexedKeyRule = append(indexedKeyRule, indexedKeyItem)
|
|
}
|
|
|
|
logs, sub, err := _TextResolver.contract.FilterLogs(opts, "TextChanged", nodeRule, indexedKeyRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TextResolverTextChangedIterator{contract: _TextResolver.contract, event: "TextChanged", logs: logs, sub: sub}, nil
|
|
}
|
|
|
|
// WatchTextChanged is a free log subscription operation binding the contract event 0xd8c9334b1a9c2f9da342a0a2b32629c1a229b6445dad78947f674b44444a7550.
|
|
//
|
|
// Solidity: event TextChanged(bytes32 indexed node, string indexed indexedKey, string key)
|
|
func (_TextResolver *TextResolverFilterer) WatchTextChanged(opts *bind.WatchOpts, sink chan<- *TextResolverTextChanged, node [][32]byte, indexedKey []string) (event.Subscription, error) {
|
|
|
|
var nodeRule []interface{}
|
|
for _, nodeItem := range node {
|
|
nodeRule = append(nodeRule, nodeItem)
|
|
}
|
|
var indexedKeyRule []interface{}
|
|
for _, indexedKeyItem := range indexedKey {
|
|
indexedKeyRule = append(indexedKeyRule, indexedKeyItem)
|
|
}
|
|
|
|
logs, sub, err := _TextResolver.contract.WatchLogs(opts, "TextChanged", nodeRule, indexedKeyRule)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return event.NewSubscription(func(quit <-chan struct{}) error {
|
|
defer sub.Unsubscribe()
|
|
for {
|
|
select {
|
|
case log := <-logs:
|
|
// New log arrived, parse the event and forward to the user
|
|
event := new(TextResolverTextChanged)
|
|
if err := _TextResolver.contract.UnpackLog(event, "TextChanged", log); err != nil {
|
|
return err
|
|
}
|
|
event.Raw = log
|
|
|
|
select {
|
|
case sink <- event:
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
case err := <-sub.Err():
|
|
return err
|
|
case <-quit:
|
|
return nil
|
|
}
|
|
}
|
|
}), nil
|
|
}
|
|
|
|
// ParseTextChanged is a log parse operation binding the contract event 0xd8c9334b1a9c2f9da342a0a2b32629c1a229b6445dad78947f674b44444a7550.
|
|
//
|
|
// Solidity: event TextChanged(bytes32 indexed node, string indexed indexedKey, string key)
|
|
func (_TextResolver *TextResolverFilterer) ParseTextChanged(log types.Log) (*TextResolverTextChanged, error) {
|
|
event := new(TextResolverTextChanged)
|
|
if err := _TextResolver.contract.UnpackLog(event, "TextChanged", log); err != nil {
|
|
return nil, err
|
|
}
|
|
event.Raw = log
|
|
return event, nil
|
|
}
|