mirror of https://github.com/ethereum/go-ethereum
Nick Johnson
8 years ago
parent
5fc032a9d1
commit
6976e602f6
@ -0,0 +1,20 @@ |
||||
# Swarm ENS interface |
||||
|
||||
## Usage |
||||
|
||||
Full documentation for the Ethereum Name Service [can be found as EIP 137](https://github.com/ethereum/EIPs/issues/137). |
||||
This package offers a simple binding that streamlines the registration arbitrary utf8 domain names to swarm content hashes. |
||||
|
||||
## Development |
||||
|
||||
The SOL file in contract subdirectory implements the ENS root registry, a simple first-in-first-served registrar for the root namespace, and a simple resolver contract; they're used in tests, and can be used to deploy these contracts for your own purposes. |
||||
|
||||
The solidity source code can be found at [github.com/arachnid/ens/](https://github.com/arachnid/ens/). |
||||
|
||||
The go bindings for ENS contracts are generated using `abigen` via the go generator: |
||||
|
||||
```shell |
||||
godep go generate ./swarm/services/ens |
||||
``` |
||||
|
||||
see the preprocessor directives in leading comments of ens.go and ens_test.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) |
||||
} |
||||
@ -0,0 +1,226 @@ |
||||
// Ethereum Name Service contracts by Nick Johnson <nick@ethereum.org> |
||||
// |
||||
// To the extent possible under law, the person who associated CC0 with |
||||
// ENS contracts has waived all copyright and related or neighboring rights |
||||
// to ENS. |
||||
// |
||||
// You should have received a copy of the CC0 legalcode along with this |
||||
// work. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>. |
||||
|
||||
/** |
||||
* The ENS registry contract. |
||||
*/ |
||||
contract ENS { |
||||
struct Record { |
||||
address owner; |
||||
address resolver; |
||||
} |
||||
|
||||
mapping(bytes32=>Record) records; |
||||
|
||||
// Logged when the owner of a node assigns a new owner to a subnode. |
||||
event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner); |
||||
|
||||
// Logged when the owner of a node transfers ownership to a new account. |
||||
event Transfer(bytes32 indexed node, address owner); |
||||
|
||||
// Logged when the owner of a node changes the resolver for that node. |
||||
event NewResolver(bytes32 indexed node, address resolver); |
||||
|
||||
// Permits modifications only by the owner of the specified node. |
||||
modifier only_owner(bytes32 node) { |
||||
if(records[node].owner != msg.sender) throw; |
||||
_ |
||||
} |
||||
|
||||
/** |
||||
* Constructs a new ENS registrar, with the provided address as the owner of the root node. |
||||
*/ |
||||
function ENS(address owner) { |
||||
records[0].owner = owner; |
||||
} |
||||
|
||||
/** |
||||
* Returns the address that owns the specified node. |
||||
*/ |
||||
function owner(bytes32 node) constant returns (address) { |
||||
return records[node].owner; |
||||
} |
||||
|
||||
/** |
||||
* Returns the address of the resolver for the specified node. |
||||
*/ |
||||
function resolver(bytes32 node) constant returns (address) { |
||||
return records[node].resolver; |
||||
} |
||||
|
||||
/** |
||||
* Transfers ownership of a node to a new address. May only be called by the current |
||||
* owner of the node. |
||||
* @param node The node to transfer ownership of. |
||||
* @param owner The address of the new owner. |
||||
*/ |
||||
function setOwner(bytes32 node, address owner) only_owner(node) { |
||||
Transfer(node, owner); |
||||
records[node].owner = owner; |
||||
} |
||||
|
||||
/** |
||||
* Transfers ownership of a subnode sha3(node, label) to a new address. May only be |
||||
* called by the owner of the parent node. |
||||
* @param node The parent node. |
||||
* @param label The hash of the label specifying the subnode. |
||||
* @param owner The address of the new owner. |
||||
*/ |
||||
function setOwner(bytes32 node, bytes32 label, address owner) only_owner(node) { |
||||
var subnode = sha3(node, label); |
||||
NewOwner(node, label, owner); |
||||
records[subnode].owner = owner; |
||||
} |
||||
|
||||
/** |
||||
* Sets the resolver address for the specified node. |
||||
* @param node The node to update. |
||||
* @param resolver The address of the resolver. |
||||
*/ |
||||
function setResolver(bytes32 node, address resolver) only_owner(node) { |
||||
NewResolver(node, resolver); |
||||
records[node].resolver = resolver; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* A registrar that allocates subdomains to the first person to claim them. It also deploys |
||||
* a simple resolver contract and sets that as the default resolver on new names for |
||||
* convenience. |
||||
*/ |
||||
contract FIFSRegistrar { |
||||
ENS ens; |
||||
PublicResolver defaultResolver; |
||||
bytes32 rootNode; |
||||
|
||||
/** |
||||
* Constructor. |
||||
* @param ensAddr The address of the ENS registry. |
||||
* @param node The node that this registrar administers. |
||||
*/ |
||||
function FIFSRegistrar(address ensAddr, bytes32 node) { |
||||
ens = ENS(ensAddr); |
||||
defaultResolver = new PublicResolver(ensAddr); |
||||
rootNode = node; |
||||
} |
||||
|
||||
/** |
||||
* Register a name, or change the owner of an existing registration. |
||||
* @param subnode The hash of the label to register. |
||||
* @param owner The address of the new owner. |
||||
*/ |
||||
function register(bytes32 subnode, address owner) { |
||||
var node = sha3(rootNode, subnode); |
||||
var currentOwner = ens.owner(node); |
||||
if(currentOwner != 0 && currentOwner != msg.sender) |
||||
throw; |
||||
|
||||
// Temporarily set ourselves as the owner |
||||
ens.setOwner(rootNode, subnode, this); |
||||
// Set up the default resolver |
||||
ens.setResolver(node, defaultResolver); |
||||
// Set the owner to the real owner |
||||
ens.setOwner(node, owner); |
||||
} |
||||
} |
||||
|
||||
contract Resolver { |
||||
event AddrChanged(bytes32 indexed node, address a); |
||||
event ContentChanged(bytes32 indexed node, bytes32 hash); |
||||
|
||||
function has(bytes32 node, bytes32 kind) returns (bool); |
||||
function addr(bytes32 node) constant returns (address ret); |
||||
function content(bytes32 node) constant returns (bytes32 ret); |
||||
} |
||||
|
||||
/** |
||||
* A simple resolver anyone can use; only allows the owner of a node to set its |
||||
* address. |
||||
*/ |
||||
contract PublicResolver is Resolver { |
||||
ENS ens; |
||||
mapping(bytes32=>address) addresses; |
||||
mapping(bytes32=>bytes32) contents; |
||||
|
||||
modifier only_owner(bytes32 node) { |
||||
if(ens.owner(node) != msg.sender) throw; |
||||
_ |
||||
} |
||||
|
||||
/** |
||||
* Constructor. |
||||
* @param ensAddr The ENS registrar contract. |
||||
*/ |
||||
function PublicResolver(address ensAddr) { |
||||
ens = ENS(ensAddr); |
||||
} |
||||
|
||||
/** |
||||
* Fallback function. |
||||
*/ |
||||
function() { |
||||
throw; |
||||
} |
||||
|
||||
/** |
||||
* Returns true if the specified node has the specified record type. |
||||
* @param node The ENS node to query. |
||||
* @param kind The record type name, as specified in EIP137. |
||||
* @return True if this resolver has a record of the provided type on the |
||||
* provided node. |
||||
*/ |
||||
function has(bytes32 node, bytes32 kind) returns (bool) { |
||||
return (kind == "addr" && addresses[node] != 0) || |
||||
(kind == "content" && contents[node] != 0); |
||||
} |
||||
|
||||
/** |
||||
* Returns the address associated with an ENS node. |
||||
* @param node The ENS node to query. |
||||
* @return The associated address. |
||||
*/ |
||||
function addr(bytes32 node) constant returns (address ret) { |
||||
ret = addresses[node]; |
||||
if(ret == 0) |
||||
throw; |
||||
} |
||||
|
||||
/** |
||||
* Returns the content hash associated with an ENS node. |
||||
* @param node The ENS node to query. |
||||
* @return The associated content hash. |
||||
*/ |
||||
function content(bytes32 node) constant returns (bytes32 ret) { |
||||
ret = contents[node]; |
||||
if(ret == 0) |
||||
throw; |
||||
} |
||||
|
||||
/** |
||||
* Sets the address associated with an ENS node. |
||||
* May only be called by the owner of that node in the ENS registry. |
||||
* @param node The node to update. |
||||
* @param addr The address to set. |
||||
*/ |
||||
function setAddr(bytes32 node, address addr) only_owner(node) { |
||||
addresses[node] = addr; |
||||
AddrChanged(node, addr); |
||||
} |
||||
|
||||
/** |
||||
* Sets the content hash associated with an ENS node. |
||||
* May only be called by the owner of that node in the ENS registry. |
||||
* @param node The node to update. |
||||
* @param hash The content hash to set. |
||||
*/ |
||||
function setContent(bytes32 node, bytes32 hash) only_owner(node) { |
||||
contents[node] = hash; |
||||
ContentChanged(node, hash); |
||||
} |
||||
} |
||||
@ -0,0 +1,178 @@ |
||||
// Copyright 2016 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package ens |
||||
|
||||
//go:generate abigen --sol contract/ens.sol --pkg contract --out contract/ens.go
|
||||
|
||||
import ( |
||||
"math/big" |
||||
"strings" |
||||
|
||||
"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/crypto" |
||||
"github.com/ethereum/go-ethereum/contracts/ens/contract" |
||||
) |
||||
|
||||
// swarm domain name registry and resolver
|
||||
type ENS struct { |
||||
*contract.ENSSession |
||||
contractBackend bind.ContractBackend |
||||
} |
||||
|
||||
// NewENS creates a struct exposing convenient high-level operations for interacting with
|
||||
// the Ethereum Name Service.
|
||||
func NewENS(transactOpts *bind.TransactOpts, contractAddr common.Address, contractBackend bind.ContractBackend) (*ENS, error) { |
||||
ens, err := contract.NewENS(contractAddr, contractBackend) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
return &ENS{ |
||||
&contract.ENSSession{ |
||||
Contract: ens, |
||||
TransactOpts: *transactOpts, |
||||
}, |
||||
contractBackend, |
||||
}, nil |
||||
} |
||||
|
||||
// DeployENS deploys an instance of the ENS nameservice, with a 'first in first served' root registrar.
|
||||
func DeployENS(transactOpts *bind.TransactOpts, contractBackend bind.ContractBackend) (*ENS, error) { |
||||
// Deploy the ENS registry
|
||||
ensAddr, _, _, err := contract.DeployENS(transactOpts, contractBackend, transactOpts.From) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
ens, err := NewENS(transactOpts, ensAddr, contractBackend) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
// Deploy the registrar
|
||||
regAddr, _, _, err := contract.DeployFIFSRegistrar(transactOpts, contractBackend, ensAddr, [32]byte{}) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
// Set the registrar as owner of the ENS root
|
||||
_, err = ens.SetOwner([32]byte{}, regAddr) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
return ens, nil |
||||
} |
||||
|
||||
func ensParentNode(name string) (common.Hash, common.Hash) { |
||||
parts := strings.SplitN(name, ".", 2) |
||||
label := crypto.Keccak256Hash([]byte(parts[0])) |
||||
if len(parts) == 1 { |
||||
return [32]byte{}, label |
||||
} else { |
||||
parentNode, parentLabel := ensParentNode(parts[1]) |
||||
return crypto.Keccak256Hash(parentNode[:], parentLabel[:]), label |
||||
} |
||||
} |
||||
|
||||
func ensNode(name string) common.Hash { |
||||
parentNode, parentLabel := ensParentNode(name) |
||||
return crypto.Keccak256Hash(parentNode[:], parentLabel[:]) |
||||
} |
||||
|
||||
func (self *ENS) getResolver(node [32]byte) (*contract.PublicResolverSession, error) { |
||||
resolverAddr, err := self.Resolver(node) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
resolver, err := contract.NewPublicResolver(resolverAddr, self.contractBackend) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
return &contract.PublicResolverSession{ |
||||
Contract: resolver, |
||||
TransactOpts: self.TransactOpts, |
||||
}, nil |
||||
} |
||||
|
||||
func (self *ENS) getRegistrar(node [32]byte) (*contract.FIFSRegistrarSession, error) { |
||||
registrarAddr, err := self.Owner(node) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
registrar, err := contract.NewFIFSRegistrar(registrarAddr, self.contractBackend) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
return &contract.FIFSRegistrarSession{ |
||||
Contract: registrar, |
||||
TransactOpts: self.TransactOpts, |
||||
}, nil |
||||
} |
||||
|
||||
// Resolve is a non-transactional call that returns the content hash associated with a name.
|
||||
func (self *ENS) Resolve(name string) (common.Hash, error) { |
||||
node := ensNode(name) |
||||
|
||||
resolver, err := self.getResolver(node) |
||||
if err != nil { |
||||
return common.Hash{}, err |
||||
} |
||||
|
||||
ret, err := resolver.Content(node) |
||||
if err != nil { |
||||
return common.Hash{}, err |
||||
} |
||||
|
||||
return common.BytesToHash(ret[:]), nil |
||||
} |
||||
|
||||
// Register registers a new domain name for the caller, making them the owner of the new name.
|
||||
// Only works if the registrar for the parent domain implements the FIFS registrar protocol.
|
||||
func (self *ENS) Register(name string) (*types.Transaction, error) { |
||||
parentNode, label := ensParentNode(name) |
||||
|
||||
registrar, err := self.getRegistrar(parentNode) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
opts := self.TransactOpts |
||||
opts.GasLimit = big.NewInt(200000) |
||||
return registrar.Contract.Register(&opts, label, self.TransactOpts.From) |
||||
} |
||||
|
||||
// SetContentHash sets the content hash associated with a name. Only works if the caller
|
||||
// owns the name, and the associated resolver implements a `setContent` function.
|
||||
func (self *ENS) SetContentHash(name string, hash common.Hash) (*types.Transaction, error) { |
||||
node := ensNode(name) |
||||
|
||||
resolver, err := self.getResolver(node) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
opts := self.TransactOpts |
||||
opts.GasLimit = big.NewInt(200000) |
||||
return resolver.Contract.SetContent(&opts, node, hash) |
||||
} |
||||
@ -0,0 +1,67 @@ |
||||
// Copyright 2016 The go-ethereum Authors
|
||||
// This file is part of the go-ethereum library.
|
||||
//
|
||||
// The go-ethereum library is free software: you can redistribute it and/or modify
|
||||
// it under the terms of the GNU Lesser General Public License as published by
|
||||
// the Free Software Foundation, either version 3 of the License, or
|
||||
// (at your option) any later version.
|
||||
//
|
||||
// The go-ethereum library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU Lesser General Public License for more details.
|
||||
//
|
||||
// You should have received a copy of the GNU Lesser General Public License
|
||||
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
package ens |
||||
|
||||
import ( |
||||
"math/big" |
||||
"testing" |
||||
|
||||
"github.com/ethereum/go-ethereum/accounts/abi/bind" |
||||
"github.com/ethereum/go-ethereum/accounts/abi/bind/backends" |
||||
"github.com/ethereum/go-ethereum/core" |
||||
"github.com/ethereum/go-ethereum/crypto" |
||||
) |
||||
|
||||
var ( |
||||
key, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") |
||||
name = "my name on ENS" |
||||
hash = crypto.Sha3Hash([]byte("my content")) |
||||
addr = crypto.PubkeyToAddress(key.PublicKey) |
||||
) |
||||
|
||||
func TestENS(t *testing.T) { |
||||
contractBackend := backends.NewSimulatedBackend(core.GenesisAccount{Address: addr, Balance: big.NewInt(1000000000)}) |
||||
transactOpts := bind.NewKeyedTransactor(key) |
||||
// Workaround for bug estimating gas in the call to Register
|
||||
transactOpts.GasLimit = big.NewInt(1000000) |
||||
|
||||
ens, err := DeployENS(transactOpts, contractBackend) |
||||
if err != nil { |
||||
t.Fatalf("expected no error, got %v", err) |
||||
} |
||||
contractBackend.Commit() |
||||
|
||||
_, err = ens.Register(name) |
||||
if err != nil { |
||||
t.Fatalf("expected no error, got %v", err) |
||||
} |
||||
contractBackend.Commit() |
||||
|
||||
_, err = ens.SetContentHash(name, hash) |
||||
if err != nil { |
||||
t.Fatalf("expected no error, got %v", err) |
||||
} |
||||
contractBackend.Commit() |
||||
|
||||
vhost, err := ens.Resolve(name) |
||||
if err != nil { |
||||
t.Fatalf("expected no error, got %v", err) |
||||
} |
||||
if vhost != hash { |
||||
t.Fatalf("resolve error, expected %v, got %v", hash.Hex(), vhost.Hex()) |
||||
} |
||||
} |
||||
Loading…
Reference in new issue