contracts/ens: Add ENS contract binding

build/update-license.go

@@ -50,6 +50,8 @@ var (
 		"crypto/sha3/", "crypto/ecies/", "logger/glog/",
 		"crypto/secp256k1/curve.go",
 		"trie/arc.go",
+		// don't license generated files
+		"contracts/ens/contract/",
 	}
 
 	// paths with this prefix are licensed as GPL. all other files are LGPL.

contracts/ens/README.md

+# 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

contracts/ens/contract/ens.sol

+// 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);
+    }
+}

contracts/ens/ens.go

+// 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)
+}

contracts/ens/ens_test.go

+// 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())
+	}
+}