contracts/ens: Add ENS contract binding

1 files changed, 900 insertions, 0 deletions

diff --git a/contracts/ens/contract/ens.go b/contracts/ens/contract/ens.go
new file mode 100644
index 000000000..34c156e3f
--- /dev/null
+++ b/contracts/ens/contract/ens.go
@@ -0,0 +1,900 @@
+// This file is an automatically generated Go binding. Do not modify as any
+// change will likely be lost upon the next re-generation!
+
+package contract
+
+import (
+	"strings"
+
+	"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"
+)
+
+// 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"}],"type":"function"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"owner","outputs":[{"name":"","type":"address"}],"type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"resolver","type":"address"}],"name":"setResolver","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"label","type":"bytes32"},{"name":"owner","type":"address"}],"name":"setOwner","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"owner","type":"address"}],"name":"setOwner","outputs":[],"type":"function"},{"inputs":[{"name":"owner","type":"address"}],"type":"constructor"},{"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"}]`
+
+// ENSBin is the compiled bytecode used for deploying new contracts.
+const ENSBin = `0x606060405260405160208061030e83395060806040525160008080526020527fad3228b676f7d3cd4284a5443f17f1962b36e491b30a40b2405849e597ba5fb58054600160a060020a03191682179055506102b08061005e6000396000f3606060405260e060020a60003504630178b8bf811461004757806302571be31461006e5780631896f70a14610091578063569cd595146100c55780635b0fc9c3146100fc575b005b610130600435600081815260208190526040902060010154600160a060020a03165b919050565b610130600435600081815260208190526040902054600160a060020a0316610069565b6100456004356024356000828152602081905260409020548290600160a060020a0390811633919091161461014357610002565b6100456004356024356044356000838152602081905260408120548490600160a060020a039081163391909116146101b757610002565b6100456004356024356000828152602081905260409020548290600160a060020a0390811633919091161461023c57610002565b600160a060020a03166060908152602090f35b600160a060020a038216606090815281907f335721b01866dc23fbee8b6b2c7b1e14d6f05c28cd35a2c934239f94095602a090602090a2816000600050600085815260200190815260200160002060005060010160006101000a815481600160a060020a0302191690830217905550505050565b6060818152608085905260408120600160a060020a03851682529250849082907fce0457fe73731f824cc272376169235128c118b49d344817417c6d108d155e8290602090a3826000600050600084815260200190815260200160002060005060000160006101000a815481600160a060020a03021916908302179055505050505050565b600160a060020a038216606090815281907fd4735d920b0f87494915f556dd9b54c8f309026070caea5c737245152564d26690602090a2816000600050600085815260200190815260200160002060005060000160006101000a815481600160a060020a030219169083021790555050505056`
+
+// DeployENS deploys a new Ethereum contract, binding an instance of ENS to it.
+func DeployENS(auth *bind.TransactOpts, backend bind.ContractBackend, owner common.Address) (common.Address, *types.Transaction, *ENS, error) {
+	parsed, err := abi.JSON(strings.NewReader(ENSABI))
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ENSBin), backend, owner)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &ENS{ENSCaller: ENSCaller{contract: contract}, ENSTransactor: ENSTransactor{contract: contract}}, nil
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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.(bind.ContractCaller), backend.(bind.ContractTransactor))
+	if err != nil {
+		return nil, err
+	}
+	return &ENS{ENSCaller: ENSCaller{contract: contract}, ENSTransactor: ENSTransactor{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)
+	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)
+	if err != nil {
+		return nil, err
+	}
+	return &ENSTransactor{contract: contract}, nil
+}
+
+// bindENS binds a generic wrapper to an already deployed contract.
+func bindENS(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {
+	parsed, err := abi.JSON(strings.NewReader(ENSABI))
+	if err != nil {
+		return nil, err
+	}
+	return bind.NewBoundContract(address, parsed, caller, transactor), 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...)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x02571be3.
+//
+// Solidity: function owner(node bytes32) constant returns(address)
+func (_ENS *ENSCaller) Owner(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
+	var (
+		ret0 = new(common.Address)
+	)
+	out := ret0
+	err := _ENS.contract.Call(opts, out, "owner", node)
+	return *ret0, err
+}
+
+// Owner is a free data retrieval call binding the contract method 0x02571be3.
+//
+// Solidity: function owner(node bytes32) constant 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(node bytes32) constant returns(address)
+func (_ENS *ENSCallerSession) Owner(node [32]byte) (common.Address, error) {
+	return _ENS.Contract.Owner(&_ENS.CallOpts, node)
+}
+
+// Resolver is a free data retrieval call binding the contract method 0x0178b8bf.
+//
+// Solidity: function resolver(node bytes32) constant returns(address)
+func (_ENS *ENSCaller) Resolver(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
+	var (
+		ret0 = new(common.Address)
+	)
+	out := ret0
+	err := _ENS.contract.Call(opts, out, "resolver", node)
+	return *ret0, err
+}
+
+// Resolver is a free data retrieval call binding the contract method 0x0178b8bf.
+//
+// Solidity: function resolver(node bytes32) constant 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(node bytes32) constant returns(address)
+func (_ENS *ENSCallerSession) Resolver(node [32]byte) (common.Address, error) {
+	return _ENS.Contract.Resolver(&_ENS.CallOpts, node)
+}
+
+// SetOwner is a paid mutator transaction binding the contract method 0x5b0fc9c3.
+//
+// Solidity: function setOwner(node bytes32, owner address) 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(node bytes32, owner address) 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(node bytes32, owner address) returns()
+func (_ENS *ENSTransactorSession) SetOwner(node [32]byte, owner common.Address) (*types.Transaction, error) {
+	return _ENS.Contract.SetOwner(&_ENS.TransactOpts, node, owner)
+}
+
+// SetResolver is a paid mutator transaction binding the contract method 0x1896f70a.
+//
+// Solidity: function setResolver(node bytes32, resolver address) 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(node bytes32, resolver address) 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(node bytes32, resolver address) returns()
+func (_ENS *ENSTransactorSession) SetResolver(node [32]byte, resolver common.Address) (*types.Transaction, error) {
+	return _ENS.Contract.SetResolver(&_ENS.TransactOpts, node, resolver)
+}
+
+// FIFSRegistrarABI is the input ABI used to generate the binding from.
+const FIFSRegistrarABI = `[{"constant":false,"inputs":[{"name":"subnode","type":"bytes32"},{"name":"owner","type":"address"}],"name":"register","outputs":[],"type":"function"},{"inputs":[{"name":"ensAddr","type":"address"},{"name":"node","type":"bytes32"}],"type":"constructor"}]`
+
+// FIFSRegistrarBin is the compiled bytecode used for deploying new contracts.
+const FIFSRegistrarBin = `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`
+
+// DeployFIFSRegistrar deploys a new Ethereum contract, binding an instance of FIFSRegistrar to it.
+func DeployFIFSRegistrar(auth *bind.TransactOpts, backend bind.ContractBackend, ensAddr common.Address, node [32]byte) (common.Address, *types.Transaction, *FIFSRegistrar, error) {
+	parsed, err := abi.JSON(strings.NewReader(FIFSRegistrarABI))
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(FIFSRegistrarBin), backend, ensAddr, node)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &FIFSRegistrar{FIFSRegistrarCaller: FIFSRegistrarCaller{contract: contract}, FIFSRegistrarTransactor: FIFSRegistrarTransactor{contract: contract}}, nil
+}
+
+// FIFSRegistrar is an auto generated Go binding around an Ethereum contract.
+type FIFSRegistrar struct {
+	FIFSRegistrarCaller     // Read-only binding to the contract
+	FIFSRegistrarTransactor // Write-only binding to the contract
+}
+
+// FIFSRegistrarCaller is an auto generated read-only Go binding around an Ethereum contract.
+type FIFSRegistrarCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// FIFSRegistrarTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type FIFSRegistrarTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// FIFSRegistrarSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type FIFSRegistrarSession struct {
+	Contract     *FIFSRegistrar    // 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
+}
+
+// FIFSRegistrarCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type FIFSRegistrarCallerSession struct {
+	Contract *FIFSRegistrarCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts        // Call options to use throughout this session
+}
+
+// FIFSRegistrarTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type FIFSRegistrarTransactorSession struct {
+	Contract     *FIFSRegistrarTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts        // Transaction auth options to use throughout this session
+}
+
+// FIFSRegistrarRaw is an auto generated low-level Go binding around an Ethereum contract.
+type FIFSRegistrarRaw struct {
+	Contract *FIFSRegistrar // Generic contract binding to access the raw methods on
+}
+
+// FIFSRegistrarCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type FIFSRegistrarCallerRaw struct {
+	Contract *FIFSRegistrarCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// FIFSRegistrarTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type FIFSRegistrarTransactorRaw struct {
+	Contract *FIFSRegistrarTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewFIFSRegistrar creates a new instance of FIFSRegistrar, bound to a specific deployed contract.
+func NewFIFSRegistrar(address common.Address, backend bind.ContractBackend) (*FIFSRegistrar, error) {
+	contract, err := bindFIFSRegistrar(address, backend.(bind.ContractCaller), backend.(bind.ContractTransactor))
+	if err != nil {
+		return nil, err
+	}
+	return &FIFSRegistrar{FIFSRegistrarCaller: FIFSRegistrarCaller{contract: contract}, FIFSRegistrarTransactor: FIFSRegistrarTransactor{contract: contract}}, nil
+}
+
+// NewFIFSRegistrarCaller creates a new read-only instance of FIFSRegistrar, bound to a specific deployed contract.
+func NewFIFSRegistrarCaller(address common.Address, caller bind.ContractCaller) (*FIFSRegistrarCaller, error) {
+	contract, err := bindFIFSRegistrar(address, caller, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &FIFSRegistrarCaller{contract: contract}, nil
+}
+
+// NewFIFSRegistrarTransactor creates a new write-only instance of FIFSRegistrar, bound to a specific deployed contract.
+func NewFIFSRegistrarTransactor(address common.Address, transactor bind.ContractTransactor) (*FIFSRegistrarTransactor, error) {
+	contract, err := bindFIFSRegistrar(address, nil, transactor)
+	if err != nil {
+		return nil, err
+	}
+	return &FIFSRegistrarTransactor{contract: contract}, nil
+}
+
+// bindFIFSRegistrar binds a generic wrapper to an already deployed contract.
+func bindFIFSRegistrar(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {
+	parsed, err := abi.JSON(strings.NewReader(FIFSRegistrarABI))
+	if err != nil {
+		return nil, err
+	}
+	return bind.NewBoundContract(address, parsed, caller, transactor), 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 (_FIFSRegistrar *FIFSRegistrarRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
+	return _FIFSRegistrar.Contract.FIFSRegistrarCaller.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 (_FIFSRegistrar *FIFSRegistrarRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _FIFSRegistrar.Contract.FIFSRegistrarTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_FIFSRegistrar *FIFSRegistrarRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _FIFSRegistrar.Contract.FIFSRegistrarTransactor.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 (_FIFSRegistrar *FIFSRegistrarCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
+	return _FIFSRegistrar.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 (_FIFSRegistrar *FIFSRegistrarTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _FIFSRegistrar.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_FIFSRegistrar *FIFSRegistrarTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _FIFSRegistrar.Contract.contract.Transact(opts, method, params...)
+}
+
+// Register is a paid mutator transaction binding the contract method 0xd22057a9.
+//
+// Solidity: function register(subnode bytes32, owner address) returns()
+func (_FIFSRegistrar *FIFSRegistrarTransactor) Register(opts *bind.TransactOpts, subnode [32]byte, owner common.Address) (*types.Transaction, error) {
+	return _FIFSRegistrar.contract.Transact(opts, "register", subnode, owner)
+}
+
+// Register is a paid mutator transaction binding the contract method 0xd22057a9.
+//
+// Solidity: function register(subnode bytes32, owner address) returns()
+func (_FIFSRegistrar *FIFSRegistrarSession) Register(subnode [32]byte, owner common.Address) (*types.Transaction, error) {
+	return _FIFSRegistrar.Contract.Register(&_FIFSRegistrar.TransactOpts, subnode, owner)
+}
+
+// Register is a paid mutator transaction binding the contract method 0xd22057a9.
+//
+// Solidity: function register(subnode bytes32, owner address) returns()
+func (_FIFSRegistrar *FIFSRegistrarTransactorSession) Register(subnode [32]byte, owner common.Address) (*types.Transaction, error) {
+	return _FIFSRegistrar.Contract.Register(&_FIFSRegistrar.TransactOpts, subnode, owner)
+}
+
+// PublicResolverABI is the input ABI used to generate the binding from.
+const PublicResolverABI = `[{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"content","outputs":[{"name":"ret","type":"bytes32"}],"type":"function"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"addr","outputs":[{"name":"ret","type":"address"}],"type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"kind","type":"bytes32"}],"name":"has","outputs":[{"name":"","type":"bool"}],"type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"hash","type":"bytes32"}],"name":"setContent","outputs":[],"type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"addr","type":"address"}],"name":"setAddr","outputs":[],"type":"function"},{"inputs":[{"name":"ensAddr","type":"address"}],"type":"constructor"},{"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":"hash","type":"bytes32"}],"name":"ContentChanged","type":"event"}]`
+
+// PublicResolverBin is the compiled bytecode used for deploying new contracts.
+const PublicResolverBin = `0x606060405260405160208061032383395060806040525160008054600160a060020a03191682179055506102ec806100376000396000f36060604052361561004b5760e060020a60003504632dff694181146100535780633b3b57de1461007557806341b9dc2b146100a0578063c3d014d614610137578063d5fa2b00146101a3575b61020f610002565b6102116004356000818152600260205260408120549081141561022e57610002565b61021b600435600081815260016020526040812054600160a060020a03169081141561022e57610002565b6102116004356024356000817f61646472000000000000000000000000000000000000000000000000000000001480156100ef575082815260016020526040812054600160a060020a03168114155b806101305750817f636f6e74656e74000000000000000000000000000000000000000000000000001480156101305750828152600260205260408120548114155b9392505050565b61020f6004356024356000805460e060020a6302571be302606090815260648590528492600160a060020a033381169316916302571be3916084916020916024908290876161da5a03f11561000257505060405151600160a060020a0316909114905061023357610002565b61020f6004356024356000805460e060020a6302571be302606090815260648590528492600160a060020a033381169316916302571be3916084916020916024908290876161da5a03f11561000257505060405151600160a060020a0316909114905061027e57610002565b005b6060908152602090f35b600160a060020a03166060908152602090f35b919050565b6040805160008381526002602090815290839020859055848252915183927f0424b6fe0d9c3bdbece0e7879dc241bb0c22e900be8b6c168b4ee08bd9bf83bc928290030190a2505050565b6040805160008381526001602090815290839020805473ffffffffffffffffffffffffffffffffffffffff191686179055600160a060020a0385168252915183927f52d7d861f09ab3d26239d492e8968629f95e9e318cf0b73bfddc441522a15fd2928290030190a250505056`
+
+// DeployPublicResolver deploys a new Ethereum contract, binding an instance of PublicResolver to it.
+func DeployPublicResolver(auth *bind.TransactOpts, backend bind.ContractBackend, ensAddr common.Address) (common.Address, *types.Transaction, *PublicResolver, error) {
+	parsed, err := abi.JSON(strings.NewReader(PublicResolverABI))
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(PublicResolverBin), backend, ensAddr)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &PublicResolver{PublicResolverCaller: PublicResolverCaller{contract: contract}, PublicResolverTransactor: PublicResolverTransactor{contract: contract}}, nil
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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.(bind.ContractCaller), backend.(bind.ContractTransactor))
+	if err != nil {
+		return nil, err
+	}
+	return &PublicResolver{PublicResolverCaller: PublicResolverCaller{contract: contract}, PublicResolverTransactor: PublicResolverTransactor{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)
+	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)
+	if err != nil {
+		return nil, err
+	}
+	return &PublicResolverTransactor{contract: contract}, nil
+}
+
+// bindPublicResolver binds a generic wrapper to an already deployed contract.
+func bindPublicResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {
+	parsed, err := abi.JSON(strings.NewReader(PublicResolverABI))
+	if err != nil {
+		return nil, err
+	}
+	return bind.NewBoundContract(address, parsed, caller, transactor), 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...)
+}
+
+// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
+//
+// Solidity: function addr(node bytes32) constant returns(ret address)
+func (_PublicResolver *PublicResolverCaller) Addr(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
+	var (
+		ret0 = new(common.Address)
+	)
+	out := ret0
+	err := _PublicResolver.contract.Call(opts, out, "addr", node)
+	return *ret0, err
+}
+
+// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
+//
+// Solidity: function addr(node bytes32) constant returns(ret 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(node bytes32) constant returns(ret address)
+func (_PublicResolver *PublicResolverCallerSession) Addr(node [32]byte) (common.Address, error) {
+	return _PublicResolver.Contract.Addr(&_PublicResolver.CallOpts, node)
+}
+
+// Content is a free data retrieval call binding the contract method 0x2dff6941.
+//
+// Solidity: function content(node bytes32) constant returns(ret bytes32)
+func (_PublicResolver *PublicResolverCaller) Content(opts *bind.CallOpts, node [32]byte) ([32]byte, error) {
+	var (
+		ret0 = new([32]byte)
+	)
+	out := ret0
+	err := _PublicResolver.contract.Call(opts, out, "content", node)
+	return *ret0, err
+}
+
+// Content is a free data retrieval call binding the contract method 0x2dff6941.
+//
+// Solidity: function content(node bytes32) constant returns(ret bytes32)
+func (_PublicResolver *PublicResolverSession) Content(node [32]byte) ([32]byte, error) {
+	return _PublicResolver.Contract.Content(&_PublicResolver.CallOpts, node)
+}
+
+// Content is a free data retrieval call binding the contract method 0x2dff6941.
+//
+// Solidity: function content(node bytes32) constant returns(ret bytes32)
+func (_PublicResolver *PublicResolverCallerSession) Content(node [32]byte) ([32]byte, error) {
+	return _PublicResolver.Contract.Content(&_PublicResolver.CallOpts, node)
+}
+
+// Has is a paid mutator transaction binding the contract method 0x41b9dc2b.
+//
+// Solidity: function has(node bytes32, kind bytes32) returns(bool)
+func (_PublicResolver *PublicResolverTransactor) Has(opts *bind.TransactOpts, node [32]byte, kind [32]byte) (*types.Transaction, error) {
+	return _PublicResolver.contract.Transact(opts, "has", node, kind)
+}
+
+// Has is a paid mutator transaction binding the contract method 0x41b9dc2b.
+//
+// Solidity: function has(node bytes32, kind bytes32) returns(bool)
+func (_PublicResolver *PublicResolverSession) Has(node [32]byte, kind [32]byte) (*types.Transaction, error) {
+	return _PublicResolver.Contract.Has(&_PublicResolver.TransactOpts, node, kind)
+}
+
+// Has is a paid mutator transaction binding the contract method 0x41b9dc2b.
+//
+// Solidity: function has(node bytes32, kind bytes32) returns(bool)
+func (_PublicResolver *PublicResolverTransactorSession) Has(node [32]byte, kind [32]byte) (*types.Transaction, error) {
+	return _PublicResolver.Contract.Has(&_PublicResolver.TransactOpts, node, kind)
+}
+
+// SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00.
+//
+// Solidity: function setAddr(node bytes32, addr address) returns()
+func (_PublicResolver *PublicResolverTransactor) SetAddr(opts *bind.TransactOpts, node [32]byte, addr common.Address) (*types.Transaction, error) {
+	return _PublicResolver.contract.Transact(opts, "setAddr", node, addr)
+}
+
+// SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00.
+//
+// Solidity: function setAddr(node bytes32, addr address) returns()
+func (_PublicResolver *PublicResolverSession) SetAddr(node [32]byte, addr common.Address) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetAddr(&_PublicResolver.TransactOpts, node, addr)
+}
+
+// SetAddr is a paid mutator transaction binding the contract method 0xd5fa2b00.
+//
+// Solidity: function setAddr(node bytes32, addr address) returns()
+func (_PublicResolver *PublicResolverTransactorSession) SetAddr(node [32]byte, addr common.Address) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetAddr(&_PublicResolver.TransactOpts, node, addr)
+}
+
+// SetContent is a paid mutator transaction binding the contract method 0xc3d014d6.
+//
+// Solidity: function setContent(node bytes32, hash bytes32) returns()
+func (_PublicResolver *PublicResolverTransactor) SetContent(opts *bind.TransactOpts, node [32]byte, hash [32]byte) (*types.Transaction, error) {
+	return _PublicResolver.contract.Transact(opts, "setContent", node, hash)
+}
+
+// SetContent is a paid mutator transaction binding the contract method 0xc3d014d6.
+//
+// Solidity: function setContent(node bytes32, hash bytes32) returns()
+func (_PublicResolver *PublicResolverSession) SetContent(node [32]byte, hash [32]byte) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetContent(&_PublicResolver.TransactOpts, node, hash)
+}
+
+// SetContent is a paid mutator transaction binding the contract method 0xc3d014d6.
+//
+// Solidity: function setContent(node bytes32, hash bytes32) returns()
+func (_PublicResolver *PublicResolverTransactorSession) SetContent(node [32]byte, hash [32]byte) (*types.Transaction, error) {
+	return _PublicResolver.Contract.SetContent(&_PublicResolver.TransactOpts, node, hash)
+}
+
+// ResolverABI is the input ABI used to generate the binding from.
+const ResolverABI = `[{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"content","outputs":[{"name":"ret","type":"bytes32"}],"type":"function"},{"constant":true,"inputs":[{"name":"node","type":"bytes32"}],"name":"addr","outputs":[{"name":"ret","type":"address"}],"type":"function"},{"constant":false,"inputs":[{"name":"node","type":"bytes32"},{"name":"kind","type":"bytes32"}],"name":"has","outputs":[{"name":"","type":"bool"}],"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":"hash","type":"bytes32"}],"name":"ContentChanged","type":"event"}]`
+
+// ResolverBin is the compiled bytecode used for deploying new contracts.
+const ResolverBin = `0x`
+
+// DeployResolver deploys a new Ethereum contract, binding an instance of Resolver to it.
+func DeployResolver(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Resolver, error) {
+	parsed, err := abi.JSON(strings.NewReader(ResolverABI))
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ResolverBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &Resolver{ResolverCaller: ResolverCaller{contract: contract}, ResolverTransactor: ResolverTransactor{contract: contract}}, nil
+}
+
+// Resolver is an auto generated Go binding around an Ethereum contract.
+type Resolver struct {
+	ResolverCaller     // Read-only binding to the contract
+	ResolverTransactor // Write-only binding to the contract
+}
+
+// ResolverCaller is an auto generated read-only Go binding around an Ethereum contract.
+type ResolverCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ResolverTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type ResolverTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ResolverSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type ResolverSession struct {
+	Contract     *Resolver         // Generic contract binding to set the session for
+	CallOpts     bind.CallOpts     // Call options to use throughout this session
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// ResolverCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type ResolverCallerSession struct {
+	Contract *ResolverCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts   // Call options to use throughout this session
+}
+
+// ResolverTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type ResolverTransactorSession struct {
+	Contract     *ResolverTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
+}
+
+// ResolverRaw is an auto generated low-level Go binding around an Ethereum contract.
+type ResolverRaw struct {
+	Contract *Resolver // Generic contract binding to access the raw methods on
+}
+
+// ResolverCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type ResolverCallerRaw struct {
+	Contract *ResolverCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// ResolverTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type ResolverTransactorRaw struct {
+	Contract *ResolverTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewResolver creates a new instance of Resolver, bound to a specific deployed contract.
+func NewResolver(address common.Address, backend bind.ContractBackend) (*Resolver, error) {
+	contract, err := bindResolver(address, backend.(bind.ContractCaller), backend.(bind.ContractTransactor))
+	if err != nil {
+		return nil, err
+	}
+	return &Resolver{ResolverCaller: ResolverCaller{contract: contract}, ResolverTransactor: ResolverTransactor{contract: contract}}, nil
+}
+
+// NewResolverCaller creates a new read-only instance of Resolver, bound to a specific deployed contract.
+func NewResolverCaller(address common.Address, caller bind.ContractCaller) (*ResolverCaller, error) {
+	contract, err := bindResolver(address, caller, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ResolverCaller{contract: contract}, nil
+}
+
+// NewResolverTransactor creates a new write-only instance of Resolver, bound to a specific deployed contract.
+func NewResolverTransactor(address common.Address, transactor bind.ContractTransactor) (*ResolverTransactor, error) {
+	contract, err := bindResolver(address, nil, transactor)
+	if err != nil {
+		return nil, err
+	}
+	return &ResolverTransactor{contract: contract}, nil
+}
+
+// bindResolver binds a generic wrapper to an already deployed contract.
+func bindResolver(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor) (*bind.BoundContract, error) {
+	parsed, err := abi.JSON(strings.NewReader(ResolverABI))
+	if err != nil {
+		return nil, err
+	}
+	return bind.NewBoundContract(address, parsed, caller, transactor), 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 (_Resolver *ResolverRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
+	return _Resolver.Contract.ResolverCaller.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 (_Resolver *ResolverRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Resolver.Contract.ResolverTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Resolver *ResolverRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Resolver.Contract.ResolverTransactor.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 (_Resolver *ResolverCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error {
+	return _Resolver.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 (_Resolver *ResolverTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Resolver.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Resolver *ResolverTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Resolver.Contract.contract.Transact(opts, method, params...)
+}
+
+// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
+//
+// Solidity: function addr(node bytes32) constant returns(ret address)
+func (_Resolver *ResolverCaller) Addr(opts *bind.CallOpts, node [32]byte) (common.Address, error) {
+	var (
+		ret0 = new(common.Address)
+	)
+	out := ret0
+	err := _Resolver.contract.Call(opts, out, "addr", node)
+	return *ret0, err
+}
+
+// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
+//
+// Solidity: function addr(node bytes32) constant returns(ret address)
+func (_Resolver *ResolverSession) Addr(node [32]byte) (common.Address, error) {
+	return _Resolver.Contract.Addr(&_Resolver.CallOpts, node)
+}
+
+// Addr is a free data retrieval call binding the contract method 0x3b3b57de.
+//
+// Solidity: function addr(node bytes32) constant returns(ret address)
+func (_Resolver *ResolverCallerSession) Addr(node [32]byte) (common.Address, error) {
+	return _Resolver.Contract.Addr(&_Resolver.CallOpts, node)
+}
+
+// Content is a free data retrieval call binding the contract method 0x2dff6941.
+//
+// Solidity: function content(node bytes32) constant returns(ret bytes32)
+func (_Resolver *ResolverCaller) Content(opts *bind.CallOpts, node [32]byte) ([32]byte, error) {
+	var (
+		ret0 = new([32]byte)
+	)
+	out := ret0
+	err := _Resolver.contract.Call(opts, out, "content", node)
+	return *ret0, err
+}
+
+// Content is a free data retrieval call binding the contract method 0x2dff6941.
+//
+// Solidity: function content(node bytes32) constant returns(ret bytes32)
+func (_Resolver *ResolverSession) Content(node [32]byte) ([32]byte, error) {
+	return _Resolver.Contract.Content(&_Resolver.CallOpts, node)
+}
+
+// Content is a free data retrieval call binding the contract method 0x2dff6941.
+//
+// Solidity: function content(node bytes32) constant returns(ret bytes32)
+func (_Resolver *ResolverCallerSession) Content(node [32]byte) ([32]byte, error) {
+	return _Resolver.Contract.Content(&_Resolver.CallOpts, node)
+}
+
+// Has is a paid mutator transaction binding the contract method 0x41b9dc2b.
+//
+// Solidity: function has(node bytes32, kind bytes32) returns(bool)
+func (_Resolver *ResolverTransactor) Has(opts *bind.TransactOpts, node [32]byte, kind [32]byte) (*types.Transaction, error) {
+	return _Resolver.contract.Transact(opts, "has", node, kind)
+}
+
+// Has is a paid mutator transaction binding the contract method 0x41b9dc2b.
+//
+// Solidity: function has(node bytes32, kind bytes32) returns(bool)
+func (_Resolver *ResolverSession) Has(node [32]byte, kind [32]byte) (*types.Transaction, error) {
+	return _Resolver.Contract.Has(&_Resolver.TransactOpts, node, kind)
+}
+
+// Has is a paid mutator transaction binding the contract method 0x41b9dc2b.
+//
+// Solidity: function has(node bytes32, kind bytes32) returns(bool)
+func (_Resolver *ResolverTransactorSession) Has(node [32]byte, kind [32]byte) (*types.Transaction, error) {
+	return _Resolver.Contract.Has(&_Resolver.TransactOpts, node, kind)
+}