5 files changed, 85 insertions, 21 deletions
diff --git a/cmd/geth/js.go b/cmd/geth/js.go
index d63ac1015..9931b3a21 100644
--- a/cmd/geth/js.go
+++ b/cmd/geth/js.go
@@ -25,6 +25,7 @@ import (
 	"strings"
 
 	"github.com/ethereum/go-ethereum/cmd/utils"
+	"github.com/ethereum/go-ethereum/common/docserver"
 	"github.com/ethereum/go-ethereum/common/natspec"
 	"github.com/ethereum/go-ethereum/eth"
 	re "github.com/ethereum/go-ethereum/jsre"
@@ -139,9 +140,11 @@ var net = web3.net;
 	js.re.Eval(globalRegistrar + "registrar = new GlobalRegistrar(\"" + globalRegistrarAddr + "\");")
 }
 
+var ds, _ = docserver.New(utils.JSpathFlag.String())
+
 func (self *jsre) ConfirmTransaction(tx string) bool {
 	var notice string
-	nat, err := natspec.New(self.xeth, tx)
+	nat, err := natspec.New(self.xeth, tx, ds)
 	if err == nil {
 		notice, err = nat.Notice()
 	}
diff --git a/common/natspec/natspec.go b/common/natspec/natspec.go
index a9ac2d1b2..145da14fe 100644
--- a/common/natspec/natspec.go
+++ b/common/natspec/natspec.go
@@ -104,6 +104,7 @@ func NewWithDocs(abiDocJson, userDocJson []byte, tx string) (self *NatSpec, err
 		data:        data,
 	}
 
+	// load and require natspec js (but it is meant to be protected environment)
 	_, err = self.jsvm.Run(natspecJS)
 	if err != nil {
 		return
@@ -132,6 +133,7 @@ func NewWithDocs(abiDocJson, userDocJson []byte, tx string) (self *NatSpec, err
 // 	Type string `json:type`
 // }
 
+// json skeleton for abi doc (contract method definitions)
 type method struct {
 	Notice string `json:notice`
 	name   string
diff --git a/common/natspec/statereg.go b/common/natspec/statereg.go
index b76990540..53d4a3081 100644
--- a/common/natspec/statereg.go
+++ b/common/natspec/statereg.go
@@ -9,9 +9,9 @@ type StateReg struct {
 	caURL, caNatSpec string //contract addresses
 }
 
-func NewStateReg(_xeth *xeth.XEth) (self *StateReg) {
-
-	self.xeth = _xeth
+func NewStateReg(xeth *xeth.XEth) (self *StateReg) {
+	self = &StateReg{}
+	self.xeth = xeth
 	self.testCreateContracts()
 	return
 
diff --git a/common/resolver/resolver.go b/common/resolver/resolver.go
index f855aad73..ba592feb0 100644
--- a/common/resolver/resolver.go
+++ b/common/resolver/resolver.go
@@ -3,11 +3,9 @@ package resolver
 import (
 	"encoding/binary"
 	"fmt"
-	// "net/url"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/xeth"
 )
 
 /*
@@ -24,37 +22,40 @@ const (
 )
 
 type Resolver struct {
-	xeth                   *xeth.XEth
+	backend                Backend
 	urlHintContractAddress string
 	nameRegContractAddress string
 }
 
-func New(_xeth *xeth.XEth, uhca, nrca string) *Resolver {
-	return &Resolver{_xeth, uhca, nrca}
+type Backend interface {
+	StorageAt(string, string) string
 }
 
-func (self *Resolver) NameToContentHash(name string) (hash common.Hash, err error) {
+func New(eth Backend, uhca, nrca string) *Resolver {
+	return &Resolver{eth, uhca, nrca}
+}
+
+func (self *Resolver) NameToContentHash(name string) (chash common.Hash, err error) {
 	// look up in nameReg
-	hashbytes := self.xeth.StorageAt(self.nameRegContractAddress, storageAddress(0, common.Hex2Bytes(name)))
-	copy(hash[:], hashbytes[:32])
+	key := storageAddress(0, common.Hex2Bytes(name))
+	hash := self.backend.StorageAt(self.nameRegContractAddress, key)
+	copy(chash[:], common.Hex2Bytes(hash))
 	return
 }
 
-func (self *Resolver) ContentHashToUrl(hash common.Hash) (uri string, err error) {
+func (self *Resolver) ContentHashToUrl(chash common.Hash) (uri string, err error) {
 	// look up in nameReg
-
-	urlHex := self.xeth.StorageAt(self.urlHintContractAddress, storageAddress(0, hash.Bytes()))
-	uri = string(common.Hex2Bytes(urlHex))
+	key := storageAddress(0, chash[:])
+	uri = self.backend.StorageAt(self.urlHintContractAddress, key)
 	l := len(uri)
 	for (l > 0) && (uri[l-1] == 0) {
 		l--
 	}
 	uri = uri[:l]
+
 	if l == 0 {
 		err = fmt.Errorf("GetURLhint: URL hint not found")
 	}
-	// rawurl := fmt.Sprintf("bzz://%x/my/path/mycontract.s	ud", hash[:])
-	// mime type?
 	return
 }
 
diff --git a/common/resolver/resolver_test.go b/common/resolver/resolver_test.go
index ce0116664..a5b6c3b4f 100644
--- a/common/resolver/resolver_test.go
+++ b/common/resolver/resolver_test.go
@@ -2,16 +2,74 @@ package resolver
 
 import (
 	"testing"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
 )
 
-func TestNameToContentHash(t *testing.T) {
+type testBackend struct {
+	// contracts mock
+	contracts map[string](map[string]string)
+}
+
+var (
+	text     = "test"
+	codehash = common.RightPadString("1234", 64)
+	hash     = common.Bytes2Hex(crypto.Sha3([]byte(text)))
+	url      = "bzz://bzzhash/my/path/contr.act"
+)
+
+func NewTestBackend() *testBackend {
+	self := &testBackend{}
+	self.contracts = make(map[string](map[string]string))
+
+	self.contracts[nameRegContractAddress] = make(map[string]string)
+	key := storageAddress(0, common.Hex2Bytes(codehash))
+	self.contracts[nameRegContractAddress][key] = hash
+
+	self.contracts[urlHintContractAddress] = make(map[string]string)
+	key = storageAddress(0, common.Hex2Bytes(hash))
+	self.contracts[urlHintContractAddress][key] = url
 
+	return self
 }
 
-func TestContentHashToUrl(t *testing.T) {
+func (self *testBackend) StorageAt(ca, sa string) (res string) {
+	c := self.contracts[ca]
+	if c == nil {
+		return
+	}
+	res = c[sa]
+	return
+}
 
+func TestNameToContentHash(t *testing.T) {
+	b := NewTestBackend()
+	res := New(b, urlHintContractAddress, nameRegContractAddress)
+	got, err := res.NameToContentHash(codehash)
+	if err != nil {
+		t.Errorf("expected no error, got %v", err)
+	} else {
+		if common.Bytes2Hex(got[:]) != hash {
+			t.Errorf("incorrect result, expected %x, got %x: ", hash, common.Bytes2Hex(got[:]))
+		}
+	}
 }
 
-func TestNameToUrl(t *testing.T) {
+func TestContentHashToUrl(t *testing.T) {
+	b := NewTestBackend()
+	res := New(b, urlHintContractAddress, nameRegContractAddress)
+	chash := common.Hash{}
+	copy(chash[:], common.Hex2Bytes(hash))
+	got, err := res.ContentHashToUrl(chash)
+	if err != nil {
+		t.Errorf("expected no error, got %v", err)
+	} else {
+		if string(got[:]) != url {
+			t.Errorf("incorrect result, expected %v, got %s: ", url, string(got[:]))
+		}
+	}
+}
 
+func TestNameToUrl(t *testing.T) {
 }