path: root/common/resolver/resolver.go

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"
)

/*
Resolver implements the Ethereum DNS mapping
NameReg : Domain Name (or Code hash of Contract) -> Content Hash
UrlHint : Content Hash -> Url Hint

The resolver is meant to be called by the roundtripper transport implementation
of a url scheme
*/
const (
    urlHintContractAddress = "urlhint"
    nameRegContractAddress = "nameReg"
)

type Resolver struct {
    xeth                   *xeth.XEth
    urlHintContractAddress string
    nameRegContractAddress string
}

func New(_xeth *xeth.XEth, uhca, nrca string) *Resolver {
    return &Resolver{_xeth, uhca, nrca}
}

func (self *Resolver) NameToContentHash(name string) (hash common.Hash, err error) {
    // look up in nameReg
    hashbytes := self.xeth.StorageAt(self.nameRegContractAddress, storageAddress(0, common.Hex2Bytes(name)))
    copy(hash[:], hashbytes[:32])
    return
}

func (self *Resolver) ContentHashToUrl(hash 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))
    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
}

func (self *Resolver) NameToUrl(name string) (uri string, hash common.Hash, err error) {
    // look up in urlHint
    hash, err = self.NameToContentHash(name)
    if err != nil {
        return
    }
    uri, err = self.ContentHashToUrl(hash)
    return
}

func storageAddress(varidx uint32, key []byte) string {
    data := make([]byte, 64)
    binary.BigEndian.PutUint32(data[28:32], varidx)
    copy(data[32:64], key[0:32])
    return common.Bytes2Hex(crypto.Sha3(data))
}