good morning!!!!

Skip to content
Snippets Groups Projects
Commit b635cad9 authored by Zsolt Felföldi's avatar Zsolt Felföldi Committed by Viktor Trón
Browse files

NatSpec passing end to end test

parent 94489b22
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
common/natspec/natspec.go
+ 7
− 4
View file @ b635cad9
...@@ -45,18 +45,19 @@ func New(xeth *xeth.XEth, tx string, http *docserver.DocServer) (self *NatSpec, ...@@ -45,18 +45,19 @@ func New(xeth *xeth.XEth, tx string, http *docserver.DocServer) (self *NatSpec,
err = fmt.Errorf("NatSpec error: contract not found") err = fmt.Errorf("NatSpec error: contract not found")
return return
} }
codeHash := xeth.CodeAt(contractAddress) codehex := xeth.CodeAt(contractAddress)
codeHash := common.BytesToHash(crypto.Sha3(common.Hex2Bytes(codehex)))
// parse out host/domain // parse out host/domain
// set up nameresolver with natspecreg + urlhint contract addresses // set up nameresolver with natspecreg + urlhint contract addresses
res := resolver.New( res := resolver.New(
xeth, xeth,
resolver.NameRegContractAddress,
resolver.URLHintContractAddress, resolver.URLHintContractAddress,
resolver.HashRegContractAddress,
) )
// resolve host via nameReg/UrlHint Resolver // resolve host via HashReg/UrlHint Resolver
uri, hash, err := res.NameToUrl(codeHash) uri, hash, err := res.KeyToUrl(codeHash)
if err != nil { if err != nil {
return return
} }
...@@ -165,6 +166,7 @@ func (self *NatSpec) Notice() (notice string, err error) { ...@@ -165,6 +166,7 @@ func (self *NatSpec) Notice() (notice string, err error) {
} }
copy(abiKey[:], self.data[2:10]) copy(abiKey[:], self.data[2:10])
meth := self.makeAbi2method(abiKey) meth := self.makeAbi2method(abiKey)
if meth == nil { if meth == nil {
err = fmt.Errorf("abi key %x does not match any method %v") err = fmt.Errorf("abi key %x does not match any method %v")
return return
...@@ -174,6 +176,7 @@ func (self *NatSpec) Notice() (notice string, err error) { ...@@ -174,6 +176,7 @@ func (self *NatSpec) Notice() (notice string, err error) {
} }
func (self *NatSpec) noticeForMethod(tx string, name, expression string) (notice string, err error) { func (self *NatSpec) noticeForMethod(tx string, name, expression string) (notice string, err error) {
if _, err = self.jsvm.Run("var transaction = " + tx + ";"); err != nil { if _, err = self.jsvm.Run("var transaction = " + tx + ";"); err != nil {
return "", fmt.Errorf("natspec.js error setting transaction: %v", err) return "", fmt.Errorf("natspec.js error setting transaction: %v", err)
} }
......
common/natspec/natspec_e2e_test.go
+ 160
− 24
View file @ b635cad9
...@@ -6,16 +6,19 @@ import ( ...@@ -6,16 +6,19 @@ import (
"math/big" "math/big"
"os" "os"
"testing" "testing"
"time"
"github.com/ethereum/go-ethereum/accounts" "github.com/ethereum/go-ethereum/accounts"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/docserver" "github.com/ethereum/go-ethereum/common/docserver"
"github.com/ethereum/go-ethereum/common/natspec"
"github.com/ethereum/go-ethereum/common/resolver" "github.com/ethereum/go-ethereum/common/resolver"
"github.com/ethereum/go-ethereum/core" "github.com/ethereum/go-ethereum/core"
"github.com/ethereum/go-ethereum/core/state" //"github.com/ethereum/go-ethereum/core/state"
//"github.com/ethereum/go-ethereum/core/types" //"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/crypto"
"github.com/ethereum/go-ethereum/eth" "github.com/ethereum/go-ethereum/eth"
"github.com/ethereum/go-ethereum/rpc"
xe "github.com/ethereum/go-ethereum/xeth" xe "github.com/ethereum/go-ethereum/xeth"
) )
...@@ -23,19 +26,81 @@ type testFrontend struct { ...@@ -23,19 +26,81 @@ type testFrontend struct {
t *testing.T t *testing.T
ethereum *eth.Ethereum ethereum *eth.Ethereum
xeth *xe.XEth xeth *xe.XEth
stateDb *state.StateDB api *rpc.EthereumApi
coinbase string coinbase string
txc int
lastConfirm string lastConfirm string
makeNatSpec bool
} }
const testNotice = "Register key `_key` <- content `_content`"
const testExpNotice = "Register key 8.9477152217924674838424037953991966239322087453347756267410168184682657981552e+76 <- content 2.9345842665291639932787537650068479186757226656217642728276414736233000517704e+76"
const testUserDoc = `
{
"source": "...",
"language": "Solidity",
"languageVersion": 1,
"methods": {
"register(uint256,uint256)": {
"notice": "` + testNotice + `"
}
},
"invariants": [
{ "notice": "" }
],
"construction": [
{ "notice": "" }
]
}
`
const testABI = `
[{
"name": "register",
"constant": false,
"type": "function",
"inputs": [{
"name": "_key",
"type": "uint256"
}, {
"name": "_content",
"type": "uint256"
}],
"outputs": []
}]
`
const testDocs = `
{
"userdoc": ` + testUserDoc + `,
"abi": ` + testABI + `
}
`
func (f *testFrontend) UnlockAccount(acc []byte) bool { func (f *testFrontend) UnlockAccount(acc []byte) bool {
f.t.Logf("Unlocking account %v\n", common.Bytes2Hex(acc)) f.t.Logf("Unlocking account %v\n", common.Bytes2Hex(acc))
f.ethereum.AccountManager().Unlock(acc, "password") f.ethereum.AccountManager().Unlock(acc, "password")
return true return true
} }
func (f *testFrontend) ConfirmTransaction(message string) bool { func (f *testFrontend) ConfirmTransaction(tx string) bool {
f.lastConfirm = message //f.t.Logf("ConfirmTransaction called tx = %v", tx)
if f.makeNatSpec {
ds, err := docserver.New("/tmp/")
if err != nil {
f.t.Errorf("Error creating DocServer: %v", err)
}
nat, err2 := natspec.New(f.xeth, tx, ds)
if err2 == nil {
f.lastConfirm, err = nat.Notice()
if err != nil {
f.t.Errorf("Notice error: %v", err)
}
} else {
f.t.Errorf("Error creating NatSpec: %v", err2)
}
}
return true return true
} }
...@@ -89,6 +154,7 @@ func testInit(t *testing.T) (self *testFrontend) { ...@@ -89,6 +154,7 @@ func testInit(t *testing.T) (self *testFrontend) {
self = &testFrontend{t: t, ethereum: ethereum} self = &testFrontend{t: t, ethereum: ethereum}
self.xeth = xe.New(ethereum, self) self.xeth = xe.New(ethereum, self)
self.api = rpc.NewEthereumApi(self.xeth)
addr := self.xeth.Coinbase() addr := self.xeth.Coinbase()
self.coinbase = addr self.coinbase = addr
...@@ -103,8 +169,6 @@ func testInit(t *testing.T) (self *testFrontend) { ...@@ -103,8 +169,6 @@ func testInit(t *testing.T) (self *testFrontend) {
} }
t.Logf("Balance is %v", balance) t.Logf("Balance is %v", balance)
self.stateDb = self.ethereum.ChainManager().State().Copy()
return return
} }
...@@ -117,33 +181,87 @@ func (self *testFrontend) insertTx(addr, contract, fnsig string, args []string) ...@@ -117,33 +181,87 @@ func (self *testFrontend) insertTx(addr, contract, fnsig string, args []string)
data = data + common.Bytes2Hex(common.Hex2BytesFixed(arg, 32)) data = data + common.Bytes2Hex(common.Hex2BytesFixed(arg, 32))
} }
self.t.Logf("Tx data: %v", data) self.t.Logf("Tx data: %v", data)
self.xeth.Transact(addr, contract, "100000000000", "100000", "100000", data)
cb := common.HexToAddress(addr) jsontx := `
[{
"from": "` + addr + `",
"to": "0x` + contract + `",
"value": "100000000000",
"gas": "100000",
"gasPrice": "100000",
"data": "` + data + `"
}]
`
self.txc++
req := &rpc.RpcRequest{
Jsonrpc: "2.0",
Method: "eth_transact",
Params: []byte(jsontx),
Id: self.txc,
}
txcount := self.ethereum.TxPool().Size()
var reply interface{}
err0 := self.api.GetRequestReply(req, &reply)
if err0 != nil {
self.t.Errorf("GetRequestReply error: %v", err0)
}
for txcount == self.ethereum.TxPool().Size() {
time.Sleep(time.Millisecond)
}
//self.xeth.Transact(addr, contract, "100000000000", "100000", "100000", data)
}
func (self *testFrontend) applyTxs() {
coinbase := self.stateDb.GetStateObject(cb) cb := common.HexToAddress(self.coinbase)
coinbase.SetGasPool(big.NewInt(100000)) stateDb := self.ethereum.ChainManager().State().Copy()
block := self.ethereum.ChainManager().NewBlock(cb) block := self.ethereum.ChainManager().NewBlock(cb)
coinbase := stateDb.GetStateObject(cb)
coinbase.SetGasPool(big.NewInt(1000000))
txs := self.ethereum.TxPool().GetTransactions() txs := self.ethereum.TxPool().GetTransactions()
tx := txs[0]
_, gas, err := core.ApplyMessage(core.NewEnv(self.stateDb, self.ethereum.ChainManager(), tx, block), tx, coinbase)
for _, tx := range txs {
_, gas, err := core.ApplyMessage(core.NewEnv(stateDb, self.ethereum.ChainManager(), tx, block), tx, coinbase)
//self.ethereum.TxPool().RemoveSet([]*types.Transaction{tx})
time.Sleep(time.Millisecond * 100)
self.t.Logf("ApplyMessage: gas %v err %v", gas, err) self.t.Logf("ApplyMessage: gas %v err %v", gas, err)
}
self.ethereum.TxPool().RemoveSet(txs) self.ethereum.TxPool().RemoveSet(txs)
self.xeth = self.xeth.WithState(self.stateDb) self.xeth = self.xeth.WithState(stateDb)
} }
func (self *testFrontend) registerURL(hash common.Hash, url string) { func (self *testFrontend) registerURL(hash common.Hash, url string) {
hashHex := common.Bytes2Hex(hash[:]) hashHex := common.Bytes2Hex(hash[:])
urlHex := common.Bytes2Hex([]byte(url)) urlHex := common.Bytes2Hex([]byte(url))
self.insertTx(self.coinbase, core.ContractAddrURLhint, "register(bytes32,bytes32)", []string{hashHex, urlHex}) self.insertTx(self.coinbase, core.ContractAddrURLhint, "register(uint256,uint256)", []string{hashHex, urlHex})
}
func (self *testFrontend) setOwner() {
self.insertTx(self.coinbase, core.ContractAddrHashReg, "setowner()", []string{})
/*owner := self.xeth.StorageAt("0x"+core.ContractAddrHashReg, "0x0000000000000000000000000000000000000000000000000000000000000000")
self.t.Logf("owner = %v", owner)
if owner != self.coinbase {
self.t.Errorf("setowner() unsuccessful, owner != coinbase")
}*/
}
func (self *testFrontend) registerNatSpec(codehash, dochash common.Hash) {
codeHex := common.Bytes2Hex(codehash[:])
docHex := common.Bytes2Hex(dochash[:])
self.insertTx(self.coinbase, core.ContractAddrHashReg, "register(uint256,uint256)", []string{codeHex, docHex})
} }
func (self *testFrontend) testResolver() *resolver.Resolver { func (self *testFrontend) testResolver() *resolver.Resolver {
return resolver.New(self.xeth, resolver.URLHintContractAddress, resolver.NameRegContractAddress) return resolver.New(self.xeth, resolver.URLHintContractAddress, resolver.HashRegContractAddress)
} }
func TestNatspecE2E(t *testing.T) { func TestNatspecE2E(t *testing.T) {
...@@ -151,16 +269,34 @@ func TestNatspecE2E(t *testing.T) { ...@@ -151,16 +269,34 @@ func TestNatspecE2E(t *testing.T) {
tf := testInit(t) tf := testInit(t)
defer tf.ethereum.Stop() defer tf.ethereum.Stop()
ds, _ := docserver.New("/tmp/") ioutil.WriteFile("/tmp/test.content", []byte(testDocs), os.ModePerm)
dochash := common.BytesToHash(crypto.Sha3([]byte(testDocs)))
codehex := tf.xeth.CodeAt(core.ContractAddrHashReg)
codehash := common.BytesToHash(crypto.Sha3(common.Hex2Bytes(codehex)))
chash := common.BytesToHash(crypto.Sha3([]byte("kutyafasza"))) tf.setOwner()
tf.registerURL(chash, "file:///test.content") tf.registerNatSpec(codehash, dochash)
tf.registerURL(chash, "kf") tf.registerURL(dochash, "file:///test.content")
tf.applyTxs()
url, err2 := tf.testResolver().ContentHashToUrl(chash) chash, err := tf.testResolver().KeyToContentHash(codehash)
if err != nil {
t.Errorf("Can't find content hash")
}
t.Logf("chash = %x err = %v", chash, err)
url, err2 := tf.testResolver().ContentHashToUrl(dochash)
if err2 != nil {
t.Errorf("Can't find URL hint")
}
t.Logf("url = %v err = %v", url, err2)
t.Logf("URL: %v err: %v", url, err2) tf.makeNatSpec = true
tf.registerNatSpec(codehash, dochash) // call again just to get a confirm message
t.Logf("Confirm message: %v\n", tf.lastConfirm)
ds.GetAuthContent(url, chash) if tf.lastConfirm != testExpNotice {
t.Errorf("Wrong confirm message, expected '%v', got '%v'", testExpNotice, tf.lastConfirm)
}
} }
common/resolver/resolver.go
+ 18
− 12
View file @ b635cad9
...@@ -11,7 +11,7 @@ import ( ...@@ -11,7 +11,7 @@ import (
/* /*
Resolver implements the Ethereum DNS mapping Resolver implements the Ethereum DNS mapping
NameReg : Domain Name (or Code hash of Contract) -> Content Hash HashReg : Key Hash (hash of domain name or contract code) -> Content Hash
UrlHint : Content Hash -> Url Hint UrlHint : Content Hash -> Url Hint
The resolver is meant to be called by the roundtripper transport implementation The resolver is meant to be called by the roundtripper transport implementation
...@@ -19,13 +19,13 @@ of a url scheme ...@@ -19,13 +19,13 @@ of a url scheme
*/ */
const ( const (
URLHintContractAddress = core.ContractAddrURLhint URLHintContractAddress = core.ContractAddrURLhint
NameRegContractAddress = core.ContractAddrHashReg HashRegContractAddress = core.ContractAddrHashReg
) )
type Resolver struct { type Resolver struct {
backend Backend backend Backend
urlHintContractAddress string urlHintContractAddress string
nameRegContractAddress string hashRegContractAddress string
} }
type Backend interface { type Backend interface {
...@@ -36,17 +36,23 @@ func New(eth Backend, uhca, nrca string) *Resolver { ...@@ -36,17 +36,23 @@ func New(eth Backend, uhca, nrca string) *Resolver {
return &Resolver{eth, uhca, nrca} return &Resolver{eth, uhca, nrca}
} }
func (self *Resolver) NameToContentHash(name string) (chash common.Hash, err error) { func (self *Resolver) KeyToContentHash(khash common.Hash) (chash common.Hash, err error) {
// look up in nameReg // look up in hashReg
key := storageAddress(1, common.Hex2BytesFixed(name, 32)) key := storageAddress(1, khash[:])
hash := self.backend.StorageAt("0x"+self.nameRegContractAddress, key) hash := self.backend.StorageAt("0x"+self.hashRegContractAddress, key)
copy(chash[:], common.Hex2Bytes(hash))
if hash == "0x0" || len(hash) < 3 {
err = fmt.Errorf("GetHashReg: content hash not found")
return
}
copy(chash[:], common.Hex2BytesFixed(hash[2:], 32))
return return
} }
func (self *Resolver) ContentHashToUrl(chash common.Hash) (uri string, err error) { func (self *Resolver) ContentHashToUrl(chash common.Hash) (uri string, err error) {
// look up in nameReg // look up in URL reg
key := storageAddress(2, chash[:]) key := storageAddress(1, chash[:])
hex := self.backend.StorageAt("0x"+self.urlHintContractAddress, key) hex := self.backend.StorageAt("0x"+self.urlHintContractAddress, key)
uri = string(common.Hex2Bytes(hex[2:])) uri = string(common.Hex2Bytes(hex[2:]))
l := len(uri) l := len(uri)
...@@ -61,9 +67,9 @@ func (self *Resolver) ContentHashToUrl(chash common.Hash) (uri string, err error ...@@ -61,9 +67,9 @@ func (self *Resolver) ContentHashToUrl(chash common.Hash) (uri string, err error
return return
} }
func (self *Resolver) NameToUrl(name string) (uri string, hash common.Hash, err error) { func (self *Resolver) KeyToUrl(key common.Hash) (uri string, hash common.Hash, err error) {
// look up in urlHint // look up in urlHint
hash, err = self.NameToContentHash(name) hash, err = self.KeyToContentHash(key)
if err != nil { if err != nil {
return return
} }
......
common/resolver/resolver_test.go
+ 11
− 9
View file @ b635cad9
...@@ -23,12 +23,12 @@ func NewTestBackend() *testBackend { ...@@ -23,12 +23,12 @@ func NewTestBackend() *testBackend {
self := &testBackend{} self := &testBackend{}
self.contracts = make(map[string](map[string]string)) self.contracts = make(map[string](map[string]string))
self.contracts[NameRegContractAddress] = make(map[string]string) self.contracts[HashRegContractAddress] = make(map[string]string)
key := storageAddress(0, common.Hex2Bytes(codehash)) key := storageAddress(1, common.Hex2Bytes(codehash))
self.contracts[NameRegContractAddress][key] = hash self.contracts[HashRegContractAddress][key] = hash
self.contracts[URLHintContractAddress] = make(map[string]string) self.contracts[URLHintContractAddress] = make(map[string]string)
key = storageAddress(0, common.Hex2Bytes(hash)) key = storageAddress(1, common.Hex2Bytes(hash))
self.contracts[URLHintContractAddress][key] = url self.contracts[URLHintContractAddress][key] = url
return self return self
...@@ -43,10 +43,12 @@ func (self *testBackend) StorageAt(ca, sa string) (res string) { ...@@ -43,10 +43,12 @@ func (self *testBackend) StorageAt(ca, sa string) (res string) {
return return
} }
func TestNameToContentHash(t *testing.T) { func TestKeyToContentHash(t *testing.T) {
b := NewTestBackend() b := NewTestBackend()
res := New(b, URLHintContractAddress, NameRegContractAddress) res := New(b, URLHintContractAddress, HashRegContractAddress)
got, err := res.NameToContentHash(codehash) chash := common.Hash{}
copy(chash[:], common.Hex2BytesFixed(codehash, 32))
got, err := res.KeyToContentHash(chash)
if err != nil { if err != nil {
t.Errorf("expected no error, got %v", err) t.Errorf("expected no error, got %v", err)
} else { } else {
...@@ -58,7 +60,7 @@ func TestNameToContentHash(t *testing.T) { ...@@ -58,7 +60,7 @@ func TestNameToContentHash(t *testing.T) {
func TestContentHashToUrl(t *testing.T) { func TestContentHashToUrl(t *testing.T) {
b := NewTestBackend() b := NewTestBackend()
res := New(b, URLHintContractAddress, NameRegContractAddress) res := New(b, URLHintContractAddress, HashRegContractAddress)
chash := common.Hash{} chash := common.Hash{}
copy(chash[:], common.Hex2Bytes(hash)) copy(chash[:], common.Hex2Bytes(hash))
got, err := res.ContentHashToUrl(chash) got, err := res.ContentHashToUrl(chash)
...@@ -71,5 +73,5 @@ func TestContentHashToUrl(t *testing.T) { ...@@ -71,5 +73,5 @@ func TestContentHashToUrl(t *testing.T) {
} }
} }
func TestNameToUrl(t *testing.T) { func TestKeyToUrl(t *testing.T) {
} }
core/contracts.go
+ 26
− 16
View file @ b635cad9
...@@ -2,33 +2,43 @@ package core ...@@ -2,33 +2,43 @@ package core
const ( // built-in contracts address and code const ( // built-in contracts address and code
ContractAddrURLhint = "0000000000000000000000000000000000000008" ContractAddrURLhint = "0000000000000000000000000000000000000008"
//ContractCodeURLhint = "0x60bd80600c6000396000f30060003560e060020a900480632f92673214601557005b60216004356024356027565b60006000f35b6000805490816001019055506001600083815260200190815260200160002054600160a060020a0316600014806081575033600160a060020a03166001600084815260200190815260200160002054600160a060020a0316145b60885760b9565b3360016000848152602001908152602001600020819055508060026000848152602001908152602001600020819055505b505056" //ContractCodeURLhint = "0x60b180600c6000396000f30060003560e060020a90048063d66d6c1014601557005b60216004356024356027565b60006000f35b6000600083815260200190815260200160002054600160a060020a0316600014806075575033600160a060020a03166000600084815260200190815260200160002054600160a060020a0316145b607c5760ad565b3360006000848152602001908152602001600020819055508060016000848152602001908152602001600020819055505b505056"
ContractCodeURLhint = "0x60003560e060020a900480632f92673214601557005b60216004356024356027565b60006000f35b6000805490816001019055506001600083815260200190815260200160002054600160a060020a0316600014806081575033600160a060020a03166001600084815260200190815260200160002054600160a060020a0316145b60885760b9565b3360016000848152602001908152602001600020819055508060026000848152602001908152602001600020819055505b505056" ContractCodeURLhint = "0x60003560e060020a90048063d66d6c1014601557005b60216004356024356027565b60006000f35b6000600083815260200190815260200160002054600160a060020a0316600014806075575033600160a060020a03166000600084815260200190815260200160002054600160a060020a0316145b607c5760ad565b3360006000848152602001908152602001600020819055508060016000848152602001908152602001600020819055505b505056"
//"0x60b180600c6000396000f30060003560e060020a900480632f92673214601557005b60216004356024356027565b60006000f35b6000600083815260200190815260200160002054600160a060020a0316600014806075575033600160a060020a03166000600084815260200190815260200160002054600160a060020a0316145b607c5760ad565b3360006000848152602001908152602001600020819055508060016000848152602001908152602001600020819055505b505056"
/* /*
contract URLhint { contract URLhint {
function register(bytes32 _hash, bytes32 _url) { function register(uint256 _hash, uint256 _url) {
testcnt++;
if (owner[_hash] == 0 || owner[_hash] == msg.sender) { if (owner[_hash] == 0 || owner[_hash] == msg.sender) {
owner[_hash] = msg.sender; owner[_hash] = msg.sender;
url[_hash] = _url; url[_hash] = _url;
} }
} }
uint32 testcnt; mapping (uint256 => address) owner;
mapping (bytes32 => address) owner; mapping (uint256 => uint256) url;
mapping (bytes32 => bytes32) url;
} }
*/ */
ContractAddrHashReg = "0000000000000000000000000000000000000009" ContractAddrHashReg = "0000000000000000000000000000000000000009"
ContractCodeHashReg = "0x3360008190555060628060136000396000f30060003560e060020a900480632f92673214601557005b60216004356024356027565b60006000f35b600054600160a060020a031633600160a060020a031614604557605e565b8060016000848152602001908152602001600020819055505b505056" ContractCodeHashReg = "0x60003560e060020a9004806331e12c2014601f578063d66d6c1014602b57005b6025603d565b60006000f35b6037600435602435605d565b60006000f35b600054600160a060020a0316600014605357605b565b336000819055505b565b600054600160a060020a031633600160a060020a031614607b576094565b8060016000848152602001908152602001600020819055505b505056"
//ContractCodeHashReg = "0x609880600c6000396000f30060003560e060020a9004806331e12c2014601f578063d66d6c1014602b57005b6025603d565b60006000f35b6037600435602435605d565b60006000f35b600054600160a060020a0316600014605357605b565b336000819055505b565b600054600160a060020a031633600160a060020a031614607b576094565b8060016000848152602001908152602001600020819055505b505056"
/* /*
import "owned"; contract HashReg {
contract HashReg is owned { function setowner() {
function register(bytes32 _code, bytes32 _abi) onlyowner { if (owner == 0) {
abis[_code] = _abi; owner = msg.sender;
} }
mapping (bytes32 => bytes32) abis; }
function register(uint256 _key, uint256 _content) {
if (msg.sender == owner) {
content[_key] = _content;
}
}
address owner;
mapping (uint256 => uint256) content;
} }
*/ */
BuiltInContracts = `
"` + ContractAddrURLhint + `": {"balance": "0", "code": "` + ContractCodeURLhint + `" },
"` + ContractAddrHashReg + `": {"balance": "0", "code": "` + ContractCodeHashReg + `" },
`
) )
core/genesis.go
+ 2
− 3
View file @ b635cad9
...@@ -58,13 +58,12 @@ func GenesisBlock(db common.Database) *types.Block { ...@@ -58,13 +58,12 @@ func GenesisBlock(db common.Database) *types.Block {
const ( const (
TestAccount = "e273f01c99144c438695e10f24926dc1f9fbf62d" TestAccount = "e273f01c99144c438695e10f24926dc1f9fbf62d"
TestBalance = "1000000000000000000" TestBalance = "1000000000000"
) )
var genesisData = []byte(`{ var genesisData = []byte(`{
"` + TestAccount + `": {"balance": "` + TestBalance + `"}, "` + TestAccount + `": {"balance": "` + TestBalance + `"},
"` + ContractAddrURLhint + `": {"balance": "` + TestBalance + `", "code": "` + ContractCodeURLhint + `" }, ` + BuiltInContracts + `
"` + ContractAddrHashReg + `": {"balance": "` + TestBalance + `", "code": "` + ContractCodeHashReg + `" },
"0000000000000000000000000000000000000001": {"balance": "1"}, "0000000000000000000000000000000000000001": {"balance": "1"},
"0000000000000000000000000000000000000002": {"balance": "1"}, "0000000000000000000000000000000000000002": {"balance": "1"},
"0000000000000000000000000000000000000003": {"balance": "1"}, "0000000000000000000000000000000000000003": {"balance": "1"},
......
rpc/api.go
+ 2
− 5
View file @ b635cad9
...@@ -168,11 +168,8 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err ...@@ -168,11 +168,8 @@ func (api *EthereumApi) GetRequestReply(req *RpcRequest, reply *interface{}) err
} }
// call ConfirmTransaction first // call ConfirmTransaction first
var obj []json.RawMessage tx, _ := json.Marshal(req)
if err := json.Unmarshal(req.Params, &obj); err != nil { if !api.xeth().ConfirmTransaction(string(tx)) {
return NewDecodeParamError(err.Error())
}
if !api.xeth().ConfirmTransaction(string(obj[0])) {
return fmt.Errorf("Transaction not confirmed") return fmt.Errorf("Transaction not confirmed")
} }
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment