diff --git a/cmd/geth/js.go b/cmd/geth/js.go index 0ac2e319e..d63ac1015 100644 --- a/cmd/geth/js.go +++ b/cmd/geth/js.go @@ -26,7 +26,6 @@ import ( "github.com/ethereum/go-ethereum/cmd/utils" "github.com/ethereum/go-ethereum/common/natspec" - "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/eth" re "github.com/ethereum/go-ethereum/jsre" "github.com/ethereum/go-ethereum/rpc" @@ -140,11 +139,11 @@ var net = web3.net; js.re.Eval(globalRegistrar + "registrar = new GlobalRegistrar(\"" + globalRegistrarAddr + "\");") } -func (self *jsre) ConfirmTransaction(tx *types.Transaction) bool { +func (self *jsre) ConfirmTransaction(tx string) bool { var notice string - nat, err := natspec.New() + nat, err := natspec.New(self.xeth, tx) if err == nil { - notice, err = nat.Notice(tx) + notice, err = nat.Notice() } if err != nil { notice = fmt.Sprintf("About to submit transaction: %v") diff --git a/common/natspec/natspec.go b/common/natspec/natspec.go index f6b91d03d..883e27ef3 100644 --- a/common/natspec/natspec.go +++ b/common/natspec/natspec.go @@ -1,6 +1,7 @@ package natspec import ( + "bytes" "encoding/json" "fmt" "github.com/robertkrimen/otto" @@ -8,32 +9,93 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/xeth" ) type abi2method map[[8]byte]*method type NatSpec struct { jsvm *otto.Otto - methods abi2method userDocJson, abiDocJson []byte userDoc userDoc + tx, data string // abiDoc abiDoc } // TODO: should initialise with abi and userdoc jsons -func New() (self *NatSpec, err error) { - // fetch abi, userdoc - abi := []byte("") - userdoc := []byte("") - return NewWithDocs(abi, userdoc) +func New(xeth *xeth.XEth, tx string) (self *NatSpec, err error) { + + // extract contract address from tx + + var obj map[string]json.RawMessage + err = json.Unmarshal([]byte(tx), &obj) + if err != nil { + return + } + var tmp []map[string]string + err = json.Unmarshal(obj["params"], &tmp) + if err != nil { + return + } + contractAddress := tmp[0]["to"] + + // retrieve contract hash from state + if !xeth.IsContract(contractAddress) { + err = fmt.Errorf("NatSpec error: contract not found") + return + } + codeHash := xeth.CodeAt(contractAddress) + + // retrieve natspec info content hash + + statereg := NewStateReg(xeth) + + natspecHash, err1 := statereg.GetNatSpec(codeHash) + if err1 != nil { + return nil, err1 + } + + // retrieve content + + content, err2 := statereg.GetContent(natspecHash) + if err2 != nil { + return nil, err2 + } + + // get abi, userdoc + var obj2 map[string]json.RawMessage + err = json.Unmarshal(content, &obj2) + if err != nil { + return + } + + abi := []byte(obj2["abi"]) + userdoc := []byte(obj2["userdoc"]) + + self, err = NewWithDocs(abi, userdoc, tx) + return } -func NewWithDocs(abiDocJson, userDocJson []byte) (self *NatSpec, err error) { +func NewWithDocs(abiDocJson, userDocJson []byte, tx string) (self *NatSpec, err error) { + + var obj map[string]json.RawMessage + err = json.Unmarshal([]byte(tx), &obj) + if err != nil { + return + } + var tmp []map[string]string + err = json.Unmarshal(obj["params"], &tmp) + if err != nil { + return + } + data := tmp[0]["data"] self = &NatSpec{ jsvm: otto.New(), abiDocJson: abiDocJson, userDocJson: userDocJson, + tx: tx, + data: data, } _, err = self.jsvm.Run(natspecJS) @@ -74,34 +136,33 @@ type userDoc struct { } func (self *NatSpec) makeAbi2method(abiKey [8]byte) (meth *method) { - if self.methods != nil { - meth = self.methods[abiKey] - return - } - self.methods = make(abi2method) for signature, m := range self.userDoc.Methods { name := strings.Split(signature, "(")[0] hash := []byte(common.Bytes2Hex(crypto.Sha3([]byte(signature)))) var key [8]byte copy(key[:], hash[:8]) - self.methods[key] = meth - meth.name = name - if key == abiKey { + if bytes.Equal(key[:], abiKey[:]) { meth = m + meth.name = name + return } } return } -func (self *NatSpec) Notice(tx string, abi string) (notice string, err error) { +func (self *NatSpec) Notice() (notice string, err error) { var abiKey [8]byte - copy(abiKey[:], []byte(abi)[:8]) + if len(self.data) < 10 { + err = fmt.Errorf("Invalid transaction data") + return + } + copy(abiKey[:], self.data[2:10]) meth := self.makeAbi2method(abiKey) if meth == nil { err = fmt.Errorf("abi key %x does not match any method %v") return } - notice, err = self.noticeForMethod(tx, meth.name, meth.Notice) + notice, err = self.noticeForMethod(self.tx, meth.name, meth.Notice) return } diff --git a/common/natspec/natspec_test.go b/common/natspec/natspec_test.go index 39c80a155..ac894e9b1 100644 --- a/common/natspec/natspec_test.go +++ b/common/natspec/natspec_test.go @@ -12,10 +12,10 @@ func makeUserdoc(desc string) []byte { "languageVersion": 1, "methods": { "multiply(uint256)": { - "notice": ` + desc + ` + "notice": "` + desc + `" }, "balance(address)": { - "notice": "` + "`(balanceInmGAV / 1000).fixed(0,3)`" + ` GAV is the total funds available to ` + "`who.address()`." + ` + "notice": "` + "`(balanceInmGAV / 1000).fixed(0,3)`" + ` GAV is the total funds available to ` + "`who.address()`." + `" } }, "invariants": [ @@ -65,12 +65,12 @@ func TestNotice(t *testing.T) { userdoc := makeUserdoc(desc) - ns, err := NewWithDocs(abi, userdoc) + ns, err := NewWithDocs(abi, userdoc, tx) if err != nil { t.Errorf("New: error: %v", err) } - notice, err := ns.Notice(tx, desc) + notice, err := ns.Notice() if err != nil { t.Errorf("expected no error, got %v", err) @@ -90,7 +90,7 @@ func TestMissingMethod(t *testing.T) { userdoc := makeUserdoc(desc) expected := "natspec.js error evaluating expression: Natspec evaluation failed, method does not exist" - ns, err := NewWithDocs(abi, userdoc) + ns, err := NewWithDocs(abi, userdoc, tx) if err != nil { t.Errorf("New: error: %v", err) } @@ -107,6 +107,7 @@ func TestMissingMethod(t *testing.T) { } // test invalid desc +/* func TestInvalidDesc(t *testing.T) { desc := "Will multiply 122 by \"7\" and return 854." @@ -114,11 +115,11 @@ func TestInvalidDesc(t *testing.T) { userdoc := makeUserdoc(desc) - ns, err := NewWithDocs(abi, userdoc) + ns, err := NewWithDocs(abi, userdoc, tx) if err != nil { t.Errorf("New: error: %v", err) } - notice, err := ns.Notice(tx, data) + notice, err := ns.Notice() if err == nil { t.Errorf("expected error, got nothing (notice: '%v')", err, notice) @@ -128,6 +129,7 @@ func TestInvalidDesc(t *testing.T) { } } } +*/ // test wrong input params func TestWrongInputParams(t *testing.T) { @@ -137,12 +139,12 @@ func TestWrongInputParams(t *testing.T) { userdoc := makeUserdoc(desc) - ns, err := NewWithDocs(abi, userdoc) + ns, err := NewWithDocs(abi, userdoc, tx) if err != nil { t.Errorf("New: error: %v", err) } - notice, err := ns.Notice(tx, desc) + notice, err := ns.Notice() if err == nil { t.Errorf("expected error, got nothing (notice: '%v')", notice) diff --git a/common/natspec/statereg.go b/common/natspec/statereg.go new file mode 100644 index 000000000..cb5dd4ce1 --- /dev/null +++ b/common/natspec/statereg.go @@ -0,0 +1,110 @@ +package natspec + +import ( + "encoding/binary" + "fmt" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/crypto" + "github.com/ethereum/go-ethereum/xeth" + "io/ioutil" + "net/http" +) + +type StateReg struct { + xeth *xeth.XEth + caURL, caNatSpec string //contract addresses +} + +func NewStateReg(_xeth *xeth.XEth) (self *StateReg) { + + self.xeth = _xeth + self.testCreateContracts() + return + +} + +const codeURLhint = "0x33600081905550609c8060136000396000f30060003560e060020a900480632f926732" + + "14601f578063f39ec1f714603157005b602b6004356024356044565b60006000f35b603a" + + "600435607f565b8060005260206000f35b600054600160a060020a031633600160a06002" + + "0a031614606257607b565b8060016000848152602001908152602001600020819055505b" + + "5050565b60006001600083815260200190815260200160002054905091905056" + +const codeNatSpec = "0x33600081905550609c8060136000396000f30060003560e060020a900480632f926732" + + "14601f578063f39ec1f714603157005b602b6004356024356044565b60006000f35b603a" + + "600435607f565b8060005260206000f35b600054600160a060020a031633600160a06002" + + "0a031614606257607b565b8060016000848152602001908152602001600020819055505b" + + "5050565b60006001600083815260200190815260200160002054905091905056" + +func (self *StateReg) testCreateContracts() { + + var err error + self.caURL, err = self.xeth.Transact(self.xeth.Coinbase(), "", "100000", "", self.xeth.DefaultGas().String(), codeURLhint) + if err != nil { + panic(err) + } + self.caNatSpec, err = self.xeth.Transact(self.xeth.Coinbase(), "", "100000", "", self.xeth.DefaultGas().String(), codeNatSpec) + if err != nil { + panic(err) + } + +} + +func (self *StateReg) GetURLhint(hash string) (url string, err error) { + + url_hex := self.xeth.StorageAt(self.caURL, storageAddress(0, common.Hex2Bytes(hash))) + url = string(common.Hex2Bytes(url_hex)) + l := len(url) + for (l > 0) && (url[l-1] == 0) { + l-- + } + url = url[:l] + if l == 0 { + err = fmt.Errorf("GetURLhint: URL hint not found") + } + 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)) +} + +func (self *StateReg) GetNatSpec(codehash string) (hash string, err error) { + + hash = self.xeth.StorageAt(self.caNatSpec, storageAddress(0, common.Hex2Bytes(codehash))) + return + +} + +func (self *StateReg) GetContent(hash string) (content []byte, err error) { + + // get URL + url, err := self.GetURLhint(hash) + if err != nil { + return + } + + // retrieve content + resp, err := http.Get(url) + defer resp.Body.Close() + if err != nil { + return + } + content, err = ioutil.ReadAll(resp.Body) + if err != nil { + return + } + + // check hash + + if common.Bytes2Hex(crypto.Sha3(content)) != hash { + content = nil + err = fmt.Errorf("GetContent error: content hash mismatch") + } + + return + +} diff --git a/rpc/api.go b/rpc/api.go index bf5066f9a..c02b03fb6 100644 --- a/rpc/api.go +++ b/rpc/api.go @@ -2,7 +2,7 @@ package rpc import ( "encoding/json" - // "fmt" + "fmt" "math/big" "sync" @@ -167,6 +167,15 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err return err } + // call ConfirmTransaction first + var obj []json.RawMessage + if err := json.Unmarshal(req.Params, &obj); err != nil { + return NewDecodeParamError(err.Error()) + } + if !api.xeth().ConfirmTransaction(string(obj[0])) { + return fmt.Errorf("Transaction not confirmed") + } + v, err := api.xeth().Transact(args.From, args.To, args.Value.String(), args.Gas.String(), args.GasPrice.String(), args.Data) if err != nil { return err diff --git a/xeth/frontend.go b/xeth/frontend.go index 8deb5c98c..fe1d57c50 100644 --- a/xeth/frontend.go +++ b/xeth/frontend.go @@ -1,9 +1,5 @@ package xeth -import ( - "github.com/ethereum/go-ethereum/core/types" -) - // Frontend should be implemented by users of XEth. Its methods are // called whenever XEth makes a decision that requires user input. type Frontend interface { @@ -21,12 +17,12 @@ type Frontend interface { // // ConfirmTransaction is not used for Call transactions // because they cannot change any state. - ConfirmTransaction(tx *types.Transaction) bool + ConfirmTransaction(tx string) bool } // dummyFrontend is a non-interactive frontend that allows all // transactions but cannot not unlock any keys. type dummyFrontend struct{} -func (dummyFrontend) UnlockAccount([]byte) bool { return false } -func (dummyFrontend) ConfirmTransaction(*types.Transaction) bool { return true } +func (dummyFrontend) UnlockAccount([]byte) bool { return false } +func (dummyFrontend) ConfirmTransaction(string) bool { return true } diff --git a/xeth/xeth.go b/xeth/xeth.go index c1a2ec283..b8a170c5b 100644 --- a/xeth/xeth.go +++ b/xeth/xeth.go @@ -608,6 +608,12 @@ func (self *XEth) Call(fromStr, toStr, valueStr, gasStr, gasPriceStr, dataStr st return common.ToHex(res), err } +func (self *XEth) ConfirmTransaction(tx string) bool { + + return self.frontend.ConfirmTransaction(tx) + +} + func (self *XEth) Transact(fromStr, toStr, valueStr, gasStr, gasPriceStr, codeStr string) (string, error) { var ( from = common.HexToAddress(fromStr)