mirror of
https://gitlab.com/pulsechaincom/erigon-pulse.git
synced 2024-12-25 13:07:17 +00:00
300 lines
7.8 KiB
Go
300 lines
7.8 KiB
Go
package natspec
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"math/big"
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/ethereum/go-ethereum/accounts"
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"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/core"
|
|
//"github.com/ethereum/go-ethereum/core/state"
|
|
//"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/crypto"
|
|
"github.com/ethereum/go-ethereum/eth"
|
|
"github.com/ethereum/go-ethereum/rpc"
|
|
xe "github.com/ethereum/go-ethereum/xeth"
|
|
)
|
|
|
|
type testFrontend struct {
|
|
t *testing.T
|
|
ethereum *eth.Ethereum
|
|
xeth *xe.XEth
|
|
api *rpc.EthereumApi
|
|
coinbase 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 {
|
|
f.t.Logf("Unlocking account %v\n", common.Bytes2Hex(acc))
|
|
f.ethereum.AccountManager().Unlock(acc, "password")
|
|
return true
|
|
}
|
|
|
|
func (f *testFrontend) ConfirmTransaction(tx string) bool {
|
|
//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
|
|
}
|
|
|
|
var port = 30300
|
|
|
|
func testEth(t *testing.T) (ethereum *eth.Ethereum, err error) {
|
|
os.RemoveAll("/tmp/eth/")
|
|
err = os.MkdirAll("/tmp/eth/keys/e273f01c99144c438695e10f24926dc1f9fbf62d/", os.ModePerm)
|
|
if err != nil {
|
|
t.Errorf("%v", err)
|
|
return
|
|
}
|
|
err = os.MkdirAll("/tmp/eth/data", os.ModePerm)
|
|
if err != nil {
|
|
t.Errorf("%v", err)
|
|
return
|
|
}
|
|
ks := crypto.NewKeyStorePlain("/tmp/eth/keys")
|
|
ioutil.WriteFile("/tmp/eth/keys/e273f01c99144c438695e10f24926dc1f9fbf62d/e273f01c99144c438695e10f24926dc1f9fbf62d",
|
|
[]byte(`{"Id":"RhRXD+fNRKS4jx+7ZfEsNA==","Address":"4nPwHJkUTEOGleEPJJJtwfn79i0=","PrivateKey":"h4ACVpe74uIvi5Cg/2tX/Yrm2xdr3J7QoMbMtNX2CNc="}`), os.ModePerm)
|
|
|
|
port++
|
|
ethereum, err = eth.New(ð.Config{
|
|
DataDir: "/tmp/eth",
|
|
AccountManager: accounts.NewManager(ks),
|
|
Port: fmt.Sprintf("%d", port),
|
|
MaxPeers: 10,
|
|
Name: "test",
|
|
})
|
|
|
|
if err != nil {
|
|
t.Errorf("%v", err)
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
func testInit(t *testing.T) (self *testFrontend) {
|
|
|
|
ethereum, err := testEth(t)
|
|
if err != nil {
|
|
t.Errorf("error creating jsre, got %v", err)
|
|
return
|
|
}
|
|
err = ethereum.Start()
|
|
if err != nil {
|
|
t.Errorf("error starting ethereum: %v", err)
|
|
return
|
|
}
|
|
|
|
self = &testFrontend{t: t, ethereum: ethereum}
|
|
self.xeth = xe.New(ethereum, self)
|
|
self.api = rpc.NewEthereumApi(self.xeth)
|
|
|
|
addr := self.xeth.Coinbase()
|
|
self.coinbase = addr
|
|
if addr != "0x"+core.TestAccount {
|
|
t.Errorf("CoinBase %v does not match TestAccount 0x%v", addr, core.TestAccount)
|
|
}
|
|
t.Logf("CoinBase is %v", addr)
|
|
|
|
balance := self.xeth.BalanceAt(core.TestAccount)
|
|
if balance != core.TestBalance {
|
|
t.Errorf("Balance %v does not match TestBalance %v", balance, core.TestBalance)
|
|
}
|
|
t.Logf("Balance is %v", balance)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
func (self *testFrontend) insertTx(addr, contract, fnsig string, args []string) {
|
|
|
|
//cb := common.HexToAddress(self.coinbase)
|
|
//coinbase := self.ethereum.ChainManager().State().GetStateObject(cb)
|
|
|
|
hash := common.Bytes2Hex(crypto.Sha3([]byte(fnsig)))
|
|
data := "0x" + hash[0:8]
|
|
for _, arg := range args {
|
|
data = data + common.Bytes2Hex(common.Hex2BytesFixed(arg, 32))
|
|
}
|
|
self.t.Logf("Tx data: %v", data)
|
|
|
|
jsontx := `
|
|
[{
|
|
"from": "` + addr + `",
|
|
"to": "0x` + contract + `",
|
|
"value": "100000000000",
|
|
"gas": "100000",
|
|
"gasPrice": "100000",
|
|
"data": "` + data + `"
|
|
}]
|
|
`
|
|
req := &rpc.RpcRequest{
|
|
Jsonrpc: "2.0",
|
|
Method: "eth_transact",
|
|
Params: []byte(jsontx),
|
|
Id: 6,
|
|
}
|
|
|
|
var reply interface{}
|
|
err0 := self.api.GetRequestReply(req, &reply)
|
|
if err0 != nil {
|
|
self.t.Errorf("GetRequestReply error: %v", err0)
|
|
}
|
|
|
|
//self.xeth.Transact(addr, contract, "100000000000", "100000", "100000", data)
|
|
}
|
|
|
|
func (self *testFrontend) applyTxs() {
|
|
|
|
cb := common.HexToAddress(self.coinbase)
|
|
stateDb := self.ethereum.ChainManager().State().Copy()
|
|
block := self.ethereum.ChainManager().NewBlock(cb)
|
|
coinbase := stateDb.GetStateObject(cb)
|
|
coinbase.SetGasPool(big.NewInt(1000000))
|
|
txs := self.ethereum.TxPool().GetTransactions()
|
|
|
|
for i := 0; i < len(txs); i++ {
|
|
for _, tx := range txs {
|
|
if tx.Nonce() == uint64(i) {
|
|
_, gas, err := core.ApplyMessage(core.NewEnv(stateDb, self.ethereum.ChainManager(), tx, block), tx, coinbase)
|
|
//self.ethereum.TxPool().RemoveSet([]*types.Transaction{tx})
|
|
self.t.Logf("ApplyMessage: gas %v err %v", gas, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
self.ethereum.TxPool().RemoveSet(txs)
|
|
self.xeth = self.xeth.WithState(stateDb)
|
|
|
|
}
|
|
|
|
func (self *testFrontend) registerURL(hash common.Hash, url string) {
|
|
hashHex := common.Bytes2Hex(hash[:])
|
|
urlHex := common.Bytes2Hex([]byte(url))
|
|
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 {
|
|
return resolver.New(self.xeth, resolver.URLHintContractAddress, resolver.HashRegContractAddress)
|
|
}
|
|
|
|
func TestNatspecE2E(t *testing.T) {
|
|
|
|
tf := testInit(t)
|
|
defer tf.ethereum.Stop()
|
|
|
|
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)))
|
|
|
|
tf.setOwner()
|
|
tf.registerNatSpec(codehash, dochash)
|
|
tf.registerURL(dochash, "file:///test.content")
|
|
tf.applyTxs()
|
|
|
|
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)
|
|
|
|
tf.makeNatSpec = true
|
|
tf.registerNatSpec(codehash, dochash) // call again just to get a confirm message
|
|
t.Logf("Confirm message: %v\n", tf.lastConfirm)
|
|
|
|
if tf.lastConfirm != testExpNotice {
|
|
t.Errorf("Wrong confirm message, expected '%v', got '%v'", testExpNotice, tf.lastConfirm)
|
|
}
|
|
|
|
}
|