diff --git a/.gitignore b/.gitignore
index 8dc689c1a6c46aa74e5cb936cf58d99f8b8dc689..062ac40a40e60a8deb295da0d715829b791ee5b6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,4 +13,6 @@ debug
.idea
.vscode
-.gopath_bos
\ No newline at end of file
+.gopath_bos
+burrow.toml
+
diff --git a/Gopkg.lock b/Gopkg.lock
index 0c65789c68d8b397a022d323da2413f848968e9b..99eff5eeb676cebb4462eedf0560de196c54c395 100644
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -281,13 +281,7 @@
name = "github.com/tendermint/iavl"
packages = ["."]
revision = "594cc0c062a7174475f0ab654384038d77067917"
- version = "v0.2.0"
-
-[[projects]]
- name = "github.com/tendermint/merkleeyes"
- packages = ["iavl"]
- revision = "102aaf5a8ffda1846413fb22805a94def2045b9f"
- version = "v0.2.4"
+ version = "v0.5.0"
[[projects]]
name = "github.com/tendermint/tendermint"
@@ -462,8 +456,8 @@
[[projects]]
name = "gopkg.in/go-playground/validator.v9"
packages = ["."]
- revision = "3620d3c0694119b61c72071ff5a05a976e97b05a"
- version = "v9.9.4"
+ revision = "8ce234ff024d85b3848e485decba806385d6e276"
+ version = "v9.13.0"
[[projects]]
name = "gopkg.in/tylerb/graceful.v1"
@@ -480,6 +474,6 @@
[solve-meta]
analyzer-name = "dep"
analyzer-version = 1
- inputs-digest = "305882cc35ee7345aa49517218d941e2892c5d418426973b9f9f73d9b8149330"
+ inputs-digest = "5db3ac43679cafd5f68104e93a248b62266d313aef2d8ba3bd7f3986a5a99834"
solver-name = "gps-cdcl"
solver-version = 1
diff --git a/Gopkg.toml b/Gopkg.toml
index b2922635322c2d74b742e007fa1a81b5f3b08aad..b1f9779a1f7fc121303e95d73ea11a438bde1664 100644
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -1,14 +1,8 @@
-required = ["github.com/tendermint/iavl"]
-
[prune]
go-tests = true
unused-packages = true
non-go = true
-[[constraint]]
- name = "github.com/tendermint/iavl"
- version = "~0.2.0"
-
[[constraint]]
name = "github.com/BurntSushi/toml"
version = "0.3.0"
@@ -73,6 +67,10 @@ required = ["github.com/tendermint/iavl"]
name = "github.com/tendermint/go-wire"
version = "~0.7.2"
+[[constraint]]
+ name = "github.com/tendermint/iavl"
+ version = "~0.5.0"
+
[[constraint]]
name = "github.com/tendermint/merkleeyes"
version = "~0.2.4"
diff --git a/Makefile b/Makefile
index 7bda2257aea480aaa7195aa83c55f8628e6f9f5d..ba7048e3fe3d39db21a656fc2287e6eee95389e5 100644
--- a/Makefile
+++ b/Makefile
@@ -141,7 +141,7 @@ test: check
.PHONY: test_integration
test_integration:
- @go get -u github.com/monax/bosmarmot/keys/cmd/monax-keys
+ @go get github.com/monax/bosmarmot/keys/cmd/monax-keys
@go test ./keys/integration -tags integration
@go test ./rpc/tm/integration -tags integration
diff --git a/account/address.go b/account/address.go
index 2340afd48a4fd4c4b52f8beceddc29dd5e1481b6..70353baccef9a398392e0a7be6d596e611523064 100644
--- a/account/address.go
+++ b/account/address.go
@@ -1,6 +1,7 @@
package account
import (
+ "bytes"
"encoding/json"
"fmt"
@@ -11,6 +12,19 @@ import (
type Address binary.Word160
+type Addresses []Address
+
+func (as Addresses) Len() int {
+ return len(as)
+}
+
+func (as Addresses) Less(i, j int) bool {
+ return bytes.Compare(as[i][:], as[j][:]) < 0
+}
+func (as Addresses) Swap(i, j int) {
+ as[i], as[j] = as[j], as[i]
+}
+
const AddressHexLength = 2 * binary.Word160Length
var ZeroAddress = Address{}
diff --git a/account/address_test.go b/account/address_test.go
index 3ea47daa8672bfbd3528bc749732bc1f17c10cd7..5a1572b34d1d763435b2d3961d597ab9a56dd1e5 100644
--- a/account/address_test.go
+++ b/account/address_test.go
@@ -1,9 +1,9 @@
package account
import (
- "testing"
-
"encoding/json"
+ "sort"
+ "testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@@ -70,3 +70,19 @@ func TestAddress_Length(t *testing.T) {
err = addrOut.UnmarshalText(([]byte)("49EA30FCAE731BDE36742F85901549F515EA1A1020"))
assert.Error(t, err, "address too long")
}
+
+func TestAddress_Sort(t *testing.T) {
+ addresses := Addresses{
+ {2, 3, 4},
+ {3, 1, 2},
+ {2, 1, 2},
+ }
+ sorted := make(Addresses, len(addresses))
+ copy(sorted, addresses)
+ sort.Stable(sorted)
+ assert.Equal(t, Addresses{
+ {2, 1, 2},
+ {2, 3, 4},
+ {3, 1, 2},
+ }, sorted)
+}
diff --git a/account/state.go b/account/state.go
index dcbba2424d1ba3227682e5d8a564bdb9998845c9..5569fbe636afc94f665f40970fe6267d5a7dac58 100644
--- a/account/state.go
+++ b/account/state.go
@@ -63,3 +63,11 @@ type StateWriter interface {
Updater
StorageSetter
}
+
+type IterableStateWriter interface {
+ StateReader
+ Updater
+ StorageSetter
+ Iterable
+ StorageIterable
+}
diff --git a/account/state_cache.go b/account/state_cache.go
new file mode 100644
index 0000000000000000000000000000000000000000..28b6d0c58affd8a2f3383847459985b0ebd2a241
--- /dev/null
+++ b/account/state_cache.go
@@ -0,0 +1,255 @@
+// Copyright 2017 Monax Industries Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package account
+
+import (
+ "fmt"
+ "sort"
+ "sync"
+
+ "github.com/hyperledger/burrow/binary"
+)
+
+type StateCache interface {
+ IterableStateWriter
+ Sync(state StateWriter) error
+ Reset(backend StateIterable)
+ Flush(state IterableStateWriter) error
+ Backend() StateIterable
+}
+
+type stateCache struct {
+ sync.RWMutex
+ backend StateIterable
+ accounts map[Address]*accountInfo
+}
+
+type accountInfo struct {
+ sync.RWMutex
+ account Account
+ storage map[binary.Word256]binary.Word256
+ removed bool
+ updated bool
+}
+
+// Returns a StateCache that wraps an underlying StateReader to use on a cache miss, can write to an output StateWriter
+// via Sync. Goroutine safe for concurrent access.
+func NewStateCache(backend StateIterable) StateCache {
+ return &stateCache{
+ backend: backend,
+ accounts: make(map[Address]*accountInfo),
+ }
+}
+
+func (cache *stateCache) GetAccount(address Address) (Account, error) {
+ accInfo, err := cache.get(address)
+ if err != nil {
+ return nil, err
+ }
+ accInfo.RLock()
+ defer accInfo.RUnlock()
+ if accInfo.removed {
+ return nil, nil
+ }
+ return accInfo.account, nil
+}
+
+func (cache *stateCache) UpdateAccount(account Account) error {
+ accInfo, err := cache.get(account.Address())
+ if err != nil {
+ return err
+ }
+ accInfo.Lock()
+ defer accInfo.Unlock()
+ if accInfo.removed {
+ return fmt.Errorf("UpdateAccount on a removed account: %s", account.Address())
+ }
+ accInfo.account = account
+ accInfo.updated = true
+ return nil
+}
+
+func (cache *stateCache) RemoveAccount(address Address) error {
+ accInfo, err := cache.get(address)
+ if err != nil {
+ return err
+ }
+ accInfo.Lock()
+ defer accInfo.Unlock()
+ if accInfo.removed {
+ return fmt.Errorf("RemoveAccount on a removed account: %s", address)
+ }
+ accInfo.removed = true
+ return nil
+}
+
+// Iterates over all accounts first in cache and then in backend until consumer returns true for 'stop'
+func (cache *stateCache) IterateAccounts(consumer func(Account) (stop bool)) (stopped bool, err error) {
+ // Try cache first for early exit
+ cache.RLock()
+ for _, info := range cache.accounts {
+ if consumer(info.account) {
+ return true, nil
+ }
+ }
+ cache.RUnlock()
+ return cache.backend.IterateAccounts(consumer)
+}
+
+func (cache *stateCache) GetStorage(address Address, key binary.Word256) (binary.Word256, error) {
+ accInfo, err := cache.get(address)
+ if err != nil {
+ return binary.Zero256, err
+ }
+ // Check cache
+ accInfo.RLock()
+ value, ok := accInfo.storage[key]
+ accInfo.RUnlock()
+ if ok {
+ return value, nil
+ } else {
+ // Load from backend
+ value, err := cache.backend.GetStorage(address, key)
+ if err != nil {
+ return binary.Zero256, err
+ }
+ accInfo.Lock()
+ accInfo.storage[key] = value
+ accInfo.Unlock()
+ return value, nil
+ }
+}
+
+// NOTE: Set value to zero to remove.
+func (cache *stateCache) SetStorage(address Address, key binary.Word256, value binary.Word256) error {
+ accInfo, err := cache.get(address)
+ accInfo.Lock()
+ defer accInfo.Unlock()
+ if err != nil {
+ return err
+ }
+ if accInfo.removed {
+ return fmt.Errorf("SetStorage on a removed account: %s", address)
+ }
+ accInfo.storage[key] = value
+ accInfo.updated = true
+ return nil
+}
+
+// Iterates over all storage items first in cache and then in backend until consumer returns true for 'stop'
+func (cache *stateCache) IterateStorage(address Address,
+ consumer func(key, value binary.Word256) (stop bool)) (stopped bool, err error) {
+ accInfo, err := cache.get(address)
+ if err != nil {
+ return false, err
+ }
+ accInfo.RLock()
+ // Try cache first for early exit
+ for key, value := range accInfo.storage {
+ if consumer(key, value) {
+ return true, nil
+ }
+ }
+ accInfo.RUnlock()
+ return cache.backend.IterateStorage(address, consumer)
+}
+
+// Syncs changes to the backend in deterministic order. Sends storage updates before updating
+// the account they belong so that storage values can be taken account of in the update.
+func (cache *stateCache) Sync(state StateWriter) error {
+ cache.Lock()
+ defer cache.Unlock()
+ var addresses Addresses
+ for address := range cache.accounts {
+ addresses = append(addresses, address)
+ }
+
+ sort.Stable(addresses)
+ for _, address := range addresses {
+ accInfo := cache.accounts[address]
+ accInfo.RLock()
+ if accInfo.removed {
+ err := state.RemoveAccount(address)
+ if err != nil {
+ return err
+ }
+ } else if accInfo.updated {
+ var keys binary.Words256
+ for key := range accInfo.storage {
+ keys = append(keys, key)
+ }
+ // First update keys
+ sort.Stable(keys)
+ for _, key := range keys {
+ value := accInfo.storage[key]
+ err := state.SetStorage(address, key, value)
+ if err != nil {
+ return err
+ }
+ }
+ // Update account - this gives backend the opportunity to update StorageRoot after calculating the new
+ // value from any storage value updates
+ err := state.UpdateAccount(accInfo.account)
+ if err != nil {
+ return err
+ }
+ }
+ accInfo.RUnlock()
+ }
+ return nil
+}
+
+// Resets the cache to empty initialising the backing map to the same size as the previous iteration.
+func (cache *stateCache) Reset(backend StateIterable) {
+ cache.Lock()
+ defer cache.Unlock()
+ cache.backend = backend
+ cache.accounts = make(map[Address]*accountInfo, len(cache.accounts))
+}
+
+// Syncs the StateCache and Resets it to use as the backend StateReader
+func (cache *stateCache) Flush(state IterableStateWriter) error {
+ err := cache.Sync(state)
+ if err != nil {
+ return err
+ }
+ cache.Reset(state)
+ return nil
+}
+
+func (cache *stateCache) Backend() StateIterable {
+ return cache.backend
+}
+
+// Get the cache accountInfo item creating it if necessary
+func (cache *stateCache) get(address Address) (*accountInfo, error) {
+ cache.RLock()
+ accInfo := cache.accounts[address]
+ cache.RUnlock()
+ if accInfo == nil {
+ account, err := cache.backend.GetAccount(address)
+ if err != nil {
+ return nil, err
+ }
+ accInfo = &accountInfo{
+ account: account,
+ storage: make(map[binary.Word256]binary.Word256),
+ }
+ cache.Lock()
+ cache.accounts[address] = accInfo
+ cache.Unlock()
+ }
+ return accInfo, nil
+}
diff --git a/account/state_cache_test.go b/account/state_cache_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..6ecc2cdd108b2e947b567943afdcf4ccdf40565d
--- /dev/null
+++ b/account/state_cache_test.go
@@ -0,0 +1,63 @@
+package account
+
+import (
+ "testing"
+
+ "fmt"
+
+ "github.com/hyperledger/burrow/binary"
+)
+
+// TODO: write tests as part of feature branch
+type testStateReader struct {
+ Accounts map[Address]Account
+ Storage map[Address]map[binary.Word256]binary.Word256
+}
+
+func accountAndStorage(account Account, keyvals ...binary.Word256) *testStateReader {
+ return &testStateReader{}
+
+}
+
+func (tsr *testStateReader) GetAccount(address Address) (Account, error) {
+ account, ok := tsr.Accounts[address]
+ if !ok {
+ return nil, fmt.Errorf("could not find account %s", address)
+ }
+ return account, nil
+}
+
+func (tsr *testStateReader) GetStorage(address Address, key binary.Word256) (binary.Word256, error) {
+ storage, ok := tsr.Storage[address]
+ if !ok {
+ return binary.Zero256, fmt.Errorf("could not find storage for account %s", address)
+ }
+ value, ok := storage[key]
+ if !ok {
+ return binary.Zero256, fmt.Errorf("could not find key %x for account %s", key, address)
+ }
+ return value, nil
+}
+
+var _ StateReader = &testStateReader{}
+
+func TestStateCache_GetAccount(t *testing.T) {
+}
+
+func TestStateCache_UpdateAccount(t *testing.T) {
+}
+
+func TestStateCache_RemoveAccount(t *testing.T) {
+}
+
+func TestStateCache_GetStorage(t *testing.T) {
+}
+
+func TestStateCache_SetStorage(t *testing.T) {
+}
+
+func TestStateCache_Sync(t *testing.T) {
+}
+
+func TestStateCache_get(t *testing.T) {
+}
diff --git a/binary/word256.go b/binary/word256.go
index 02a90581f9c297f49c9fe08369755efa82694b3f..7bdbb4ec0e63921e44ff8b3191b2485aa3a8cb6f 100644
--- a/binary/word256.go
+++ b/binary/word256.go
@@ -114,6 +114,20 @@ func Int64FromWord256(word Word256) int64 {
//-------------------------------------
+type Words256 []Word256
+
+func (ws Words256) Len() int {
+ return len(ws)
+}
+
+func (ws Words256) Less(i, j int) bool {
+ return ws[i].Compare(ws[j]) < 0
+}
+
+func (ws Words256) Swap(i, j int) {
+ ws[i], ws[j] = ws[j], ws[i]
+}
+
type Tuple256 struct {
First Word256
Second Word256
diff --git a/blockchain/blockchain.go b/blockchain/blockchain.go
index c0816017e285443278621451039ddbd79535950a..6cda8da59ce02519dabb8159ad03a9b1310eac86 100644
--- a/blockchain/blockchain.go
+++ b/blockchain/blockchain.go
@@ -15,14 +15,21 @@
package blockchain
import (
- "time"
-
+ "bytes"
+ "encoding/json"
+ "fmt"
"sync"
+ "time"
acm "github.com/hyperledger/burrow/account"
"github.com/hyperledger/burrow/genesis"
+ "github.com/hyperledger/burrow/logging"
+ logging_types "github.com/hyperledger/burrow/logging/types"
+ dbm "github.com/tendermint/tmlibs/db"
)
+var stateKey = []byte("BlockchainState")
+
// Immutable Root of blockchain
type Root interface {
// ChainID precomputed from GenesisDoc
@@ -56,7 +63,7 @@ type Blockchain interface {
type MutableBlockchain interface {
Blockchain
- CommitBlock(blockTime time.Time, blockHash, appHash []byte)
+ CommitBlock(blockTime time.Time, blockHash, appHash []byte) error
}
type root struct {
@@ -74,6 +81,7 @@ type tip struct {
type blockchain struct {
sync.RWMutex
+ db dbm.DB
*root
*tip
validators []acm.Validator
@@ -84,8 +92,38 @@ var _ Tip = &blockchain{}
var _ Blockchain = &blockchain{}
var _ MutableBlockchain = &blockchain{}
+type PersistedState struct {
+ AppHashAfterLastBlock []byte
+ LastBlockHeight uint64
+ GenesisDoc genesis.GenesisDoc
+}
+
+func LoadOrNewBlockchain(db dbm.DB, genesisDoc *genesis.GenesisDoc,
+ logger logging_types.InfoTraceLogger) (*blockchain, error) {
+
+ logger = logging.WithScope(logger, "LoadOrNewBlockchain")
+ logging.InfoMsg(logger, "Trying to load blockchain state from database",
+ "database_key", stateKey)
+ blockchain, err := LoadBlockchain(db)
+ if err != nil {
+ return nil, fmt.Errorf("error loading blockchain state from database: %v", err)
+ }
+ if blockchain != nil {
+ dbHash := blockchain.genesisDoc.Hash()
+ argHash := genesisDoc.Hash()
+ if !bytes.Equal(dbHash, argHash) {
+ return nil, fmt.Errorf("GenesisDoc passed to LoadOrNewBlockchain has hash: 0x%X, which does not "+
+ "match the one found in database: 0x%X", argHash, dbHash)
+ }
+ return blockchain, nil
+ }
+
+ logging.InfoMsg(logger, "No existing blockchain state found in database, making new blockchain")
+ return NewBlockchain(db, genesisDoc), nil
+}
+
// Pointer to blockchain state initialised from genesis
-func NewBlockchain(genesisDoc *genesis.GenesisDoc) *blockchain {
+func NewBlockchain(db dbm.DB, genesisDoc *genesis.GenesisDoc) *blockchain {
var validators []acm.Validator
for _, gv := range genesisDoc.Validators {
validators = append(validators, acm.ConcreteValidator{
@@ -95,6 +133,7 @@ func NewBlockchain(genesisDoc *genesis.GenesisDoc) *blockchain {
}
root := NewRoot(genesisDoc)
return &blockchain{
+ db: db,
root: root,
tip: &tip{
lastBlockTime: root.genesisDoc.GenesisTime,
@@ -104,6 +143,21 @@ func NewBlockchain(genesisDoc *genesis.GenesisDoc) *blockchain {
}
}
+func LoadBlockchain(db dbm.DB) (*blockchain, error) {
+ buf := db.Get(stateKey)
+ if len(buf) == 0 {
+ return nil, nil
+ }
+ persistedState, err := Decode(buf)
+ if err != nil {
+ return nil, err
+ }
+ blockchain := NewBlockchain(db, &persistedState.GenesisDoc)
+ blockchain.lastBlockHeight = persistedState.LastBlockHeight
+ blockchain.appHashAfterLastBlock = persistedState.AppHashAfterLastBlock
+ return blockchain, nil
+}
+
func NewRoot(genesisDoc *genesis.GenesisDoc) *root {
return &root{
chainID: genesisDoc.ChainID(),
@@ -122,13 +176,25 @@ func NewTip(lastBlockHeight uint64, lastBlockTime time.Time, lastBlockHash []byt
}
}
-func (bc *blockchain) CommitBlock(blockTime time.Time, blockHash, appHash []byte) {
+func (bc *blockchain) CommitBlock(blockTime time.Time, blockHash, appHash []byte) error {
bc.Lock()
defer bc.Unlock()
bc.lastBlockHeight += 1
bc.lastBlockTime = blockTime
bc.lastBlockHash = blockHash
bc.appHashAfterLastBlock = appHash
+ return bc.save()
+}
+
+func (bc *blockchain) save() error {
+ if bc.db != nil {
+ encodedState, err := bc.Encode()
+ if err != nil {
+ return err
+ }
+ bc.db.SetSync(stateKey, encodedState)
+ }
+ return nil
}
func (bc *blockchain) Root() Root {
@@ -152,6 +218,28 @@ func (bc *blockchain) Validators() []acm.Validator {
return vs
}
+func (bc *blockchain) Encode() ([]byte, error) {
+ persistedState := &PersistedState{
+ GenesisDoc: bc.genesisDoc,
+ AppHashAfterLastBlock: bc.appHashAfterLastBlock,
+ LastBlockHeight: bc.lastBlockHeight,
+ }
+ encodedState, err := json.Marshal(persistedState)
+ if err != nil {
+ return nil, err
+ }
+ return encodedState, nil
+}
+
+func Decode(encodedState []byte) (*PersistedState, error) {
+ persistedState := new(PersistedState)
+ err := json.Unmarshal(encodedState, persistedState)
+ if err != nil {
+ return nil, err
+ }
+ return persistedState, nil
+}
+
func (r *root) ChainID() string {
return r.chainID
}
diff --git a/client/websocket_client.go b/client/websocket_client.go
index e6b257707e47c517c893f0f0ec5212e59295b46d..41ba931c3f689a2ba2a7af65631ae047d9b56f68 100644
--- a/client/websocket_client.go
+++ b/client/websocket_client.go
@@ -164,10 +164,10 @@ func (burrowNodeWebsocketClient *burrowNodeWebsocketClient) WaitForConfirmation(
return
}
- if !bytes.Equal(txs.TxHash(chainId, eventDataTx.Tx), txs.TxHash(chainId, tx)) {
+ if !bytes.Equal(eventDataTx.Tx.Hash(chainId), tx.Hash(chainId)) {
logging.TraceMsg(burrowNodeWebsocketClient.logger, "Received different event",
// TODO: consider re-implementing TxID again, or other more clear debug
- "received transaction event", txs.TxHash(chainId, eventDataTx.Tx))
+ "received transaction event", eventDataTx.Tx.Hash(chainId))
continue
}
diff --git a/consensus/tendermint/abci/app.go b/consensus/tendermint/abci/app.go
index 74be6be92ea353f09f4a87bf01b3b4d8ebbcc18b..ee549575566b2420d0f53214d94f97d6a3ce63c5 100644
--- a/consensus/tendermint/abci/app.go
+++ b/consensus/tendermint/abci/app.go
@@ -74,6 +74,7 @@ func (app *abciApp) CheckTx(txBytes []byte) abci_types.ResponseCheckTx {
tx, err := app.txDecoder.DecodeTx(txBytes)
if err != nil {
logging.TraceMsg(app.logger, "CheckTx decoding error",
+ "tag", "CheckTx",
structure.ErrorKey, err)
return abci_types.ResponseCheckTx{
Code: codes.EncodingErrorCode,
@@ -87,6 +88,7 @@ func (app *abciApp) CheckTx(txBytes []byte) abci_types.ResponseCheckTx {
if err != nil {
logging.TraceMsg(app.logger, "CheckTx execution error",
structure.ErrorKey, err,
+ "tag", "CheckTx",
"tx_hash", receipt.TxHash,
"creates_contract", receipt.CreatesContract)
return abci_types.ResponseCheckTx{
@@ -97,6 +99,7 @@ func (app *abciApp) CheckTx(txBytes []byte) abci_types.ResponseCheckTx {
receiptBytes := wire.BinaryBytes(receipt)
logging.TraceMsg(app.logger, "CheckTx success",
+ "tag", "CheckTx",
"tx_hash", receipt.TxHash,
"creates_contract", receipt.CreatesContract)
return abci_types.ResponseCheckTx{
@@ -122,6 +125,7 @@ func (app *abciApp) DeliverTx(txBytes []byte) abci_types.ResponseDeliverTx {
tx, err := app.txDecoder.DecodeTx(txBytes)
if err != nil {
logging.TraceMsg(app.logger, "DeliverTx decoding error",
+ "tag", "DeliverTx",
structure.ErrorKey, err)
return abci_types.ResponseDeliverTx{
Code: codes.EncodingErrorCode,
@@ -134,6 +138,7 @@ func (app *abciApp) DeliverTx(txBytes []byte) abci_types.ResponseDeliverTx {
if err != nil {
logging.TraceMsg(app.logger, "DeliverTx execution error",
structure.ErrorKey, err,
+ "tag", "DeliverTx",
"tx_hash", receipt.TxHash,
"creates_contract", receipt.CreatesContract)
return abci_types.ResponseDeliverTx{
@@ -143,6 +148,7 @@ func (app *abciApp) DeliverTx(txBytes []byte) abci_types.ResponseDeliverTx {
}
logging.TraceMsg(app.logger, "DeliverTx success",
+ "tag", "DeliverTx",
"tx_hash", receipt.TxHash,
"creates_contract", receipt.CreatesContract)
receiptBytes := wire.BinaryBytes(receipt)
@@ -163,29 +169,38 @@ func (app *abciApp) Commit() abci_types.ResponseCommit {
defer app.mtx.Unlock()
tip := app.blockchain.Tip()
logging.InfoMsg(app.logger, "Committing block",
+ "tag", "Commit",
structure.ScopeKey, "Commit()",
- "block_height", tip.LastBlockHeight(),
+ "block_height", app.block.Header.Height,
"block_hash", app.block.Hash,
"block_time", app.block.Header.Time,
"num_txs", app.block.Header.NumTxs,
"last_block_time", tip.LastBlockTime(),
"last_block_hash", tip.LastBlockHash())
+ err := app.checker.Reset()
+ if err != nil {
+ return abci_types.ResponseCommit{
+ Code: codes.CommitErrorCode,
+ Log: fmt.Sprintf("Could not reset check cache during commit: %s", err),
+ }
+ }
appHash, err := app.committer.Commit()
if err != nil {
return abci_types.ResponseCommit{
Code: codes.CommitErrorCode,
- Log: fmt.Sprintf("Could not commit block: %s", err),
+ Log: fmt.Sprintf("Could not commit transactions in block to execution state: %s", err),
}
}
- // Just kill the cache - it is badly implemented
- app.committer.Reset()
-
- logging.InfoMsg(app.logger, "Resetting transaction check cache")
- app.checker.Reset()
// Commit to our blockchain state
- app.blockchain.CommitBlock(time.Unix(int64(app.block.Header.Time), 0), app.block.Hash, appHash)
+ err = app.blockchain.CommitBlock(time.Unix(int64(app.block.Header.Time), 0), app.block.Hash, appHash)
+ if err != nil {
+ return abci_types.ResponseCommit{
+ Code: codes.CommitErrorCode,
+ Log: fmt.Sprintf("Could not commit block to blockchain state: %s", err),
+ }
+ }
// Perform a sanity check our block height
if app.blockchain.LastBlockHeight() != uint64(app.block.Header.Height) {
diff --git a/consensus/tendermint/query/node_view.go b/consensus/tendermint/query/node_view.go
index b0ecc2bdc9f2d3f182a3a8f5c1dd625411dc1d18..2d33ea531769461cb2d9013ce89acfa42b8ec780 100644
--- a/consensus/tendermint/query/node_view.go
+++ b/consensus/tendermint/query/node_view.go
@@ -4,10 +4,10 @@ import (
"fmt"
acm "github.com/hyperledger/burrow/account"
+ "github.com/hyperledger/burrow/consensus/tendermint"
"github.com/hyperledger/burrow/txs"
"github.com/tendermint/tendermint/consensus"
ctypes "github.com/tendermint/tendermint/consensus/types"
- "github.com/tendermint/tendermint/node"
"github.com/tendermint/tendermint/p2p"
"github.com/tendermint/tendermint/types"
)
@@ -35,11 +35,11 @@ type NodeView interface {
}
type nodeView struct {
- tmNode *node.Node
+ tmNode *tendermint.Node
txDecoder txs.Decoder
}
-func NewNodeView(tmNode *node.Node, txDecoder txs.Decoder) NodeView {
+func NewNodeView(tmNode *tendermint.Node, txDecoder txs.Decoder) NodeView {
return &nodeView{
tmNode: tmNode,
txDecoder: txDecoder,
diff --git a/consensus/tendermint/tendermint.go b/consensus/tendermint/tendermint.go
index 8f38c5befd734d4676e0aec54d3ab209c7e9480a..7a3af288ad8149f76052c1cabbb4ce467e2763c5 100644
--- a/consensus/tendermint/tendermint.go
+++ b/consensus/tendermint/tendermint.go
@@ -3,8 +3,11 @@ package tendermint
import (
"fmt"
+ "context"
+
bcm "github.com/hyperledger/burrow/blockchain"
"github.com/hyperledger/burrow/consensus/tendermint/abci"
+ "github.com/hyperledger/burrow/event"
"github.com/hyperledger/burrow/execution"
"github.com/hyperledger/burrow/genesis"
"github.com/hyperledger/burrow/logging/structure"
@@ -15,8 +18,30 @@ import (
"github.com/tendermint/tendermint/node"
"github.com/tendermint/tendermint/proxy"
tm_types "github.com/tendermint/tendermint/types"
+ dbm "github.com/tendermint/tmlibs/db"
)
+// Serves as a wrapper around the Tendermint node's closeable resources (database connections)
+type Node struct {
+ *node.Node
+ closers []interface {
+ Close()
+ }
+}
+
+// Since Tendermint doesn't close its DB connections
+func (n *Node) DBProvider(ctx *node.DBContext) (dbm.DB, error) {
+ db := dbm.NewDB(ctx.ID, ctx.Config.DBBackend, ctx.Config.DBDir())
+ n.closers = append(n.closers, db)
+ return db, nil
+}
+
+func (n *Node) Close() {
+ for _, closer := range n.closers {
+ closer.Close()
+ }
+}
+
func NewNode(
conf *config.Config,
privValidator tm_types.PrivValidator,
@@ -24,23 +49,29 @@ func NewNode(
blockchain bcm.MutableBlockchain,
checker execution.BatchExecutor,
committer execution.BatchCommitter,
- logger logging_types.InfoTraceLogger) (*node.Node, error) {
+ logger logging_types.InfoTraceLogger) (*Node, error) {
+ var err error
// disable Tendermint's RPC
conf.RPC.ListenAddress = ""
app := abci.NewApp(blockchain, checker, committer, logger)
- return node.NewNode(conf, privValidator,
+ nde := &Node{}
+ nde.Node, err = node.NewNode(conf, privValidator,
proxy.NewLocalClientCreator(app),
func() (*tm_types.GenesisDoc, error) {
return genesisDoc, nil
},
- node.DefaultDBProvider,
+ nde.DBProvider,
NewLogger(logger.WithPrefix(structure.ComponentKey, "Tendermint").
With(structure.ScopeKey, "tendermint.NewNode")))
+ if err != nil {
+ return nil, err
+ }
+ return nde, nil
}
-func BroadcastTxAsyncFunc(validator *node.Node, txEncoder txs.Encoder) func(tx txs.Tx,
+func BroadcastTxAsyncFunc(validator *Node, txEncoder txs.Encoder) func(tx txs.Tx,
callback func(res *abci_types.Response)) error {
return func(tx txs.Tx, callback func(res *abci_types.Response)) error {
@@ -73,3 +104,19 @@ func DeriveGenesisDoc(burrowGenesisDoc *genesis.GenesisDoc) *tm_types.GenesisDoc
AppHash: burrowGenesisDoc.Hash(),
}
}
+
+func SubscribeNewBlock(ctx context.Context, subscribable event.Subscribable, subscriber string,
+ ch chan<- *tm_types.EventDataNewBlock) error {
+ query := event.QueryForEventID(tm_types.EventNewBlock)
+
+ return event.SubscribeCallback(ctx, subscribable, subscriber, query, func(message interface{}) bool {
+ tmEventData, ok := message.(tm_types.TMEventData)
+ if ok {
+ eventDataNewBlock, ok := tmEventData.Unwrap().(tm_types.EventDataNewBlock)
+ if ok {
+ ch <- &eventDataNewBlock
+ }
+ }
+ return true
+ })
+}
diff --git a/core/kernel.go b/core/kernel.go
index 3562b7302c9553ace4f07250d86d1ce89d32bb19..f00cd7a9b17d0d03f690ddcd2c135a6c33b63795 100644
--- a/core/kernel.go
+++ b/core/kernel.go
@@ -32,11 +32,11 @@ import (
"github.com/hyperledger/burrow/logging"
"github.com/hyperledger/burrow/logging/structure"
logging_types "github.com/hyperledger/burrow/logging/types"
+ "github.com/hyperledger/burrow/process"
"github.com/hyperledger/burrow/rpc"
"github.com/hyperledger/burrow/rpc/tm"
"github.com/hyperledger/burrow/rpc/v0"
v0_server "github.com/hyperledger/burrow/rpc/v0/server"
- "github.com/hyperledger/burrow/server"
"github.com/hyperledger/burrow/txs"
tm_config "github.com/tendermint/tendermint/config"
tm_types "github.com/tendermint/tendermint/types"
@@ -48,28 +48,39 @@ const ServerShutdownTimeoutMilliseconds = 1000
// Kernel is the root structure of Burrow
type Kernel struct {
- emitter event.Emitter
- service rpc.Service
- serverLaunchers []server.Launcher
- servers map[string]server.Server
- logger logging_types.InfoTraceLogger
- shutdownNotify chan struct{}
- shutdownOnce sync.Once
+ // Expose these public-facing interfaces to allow programmatic extension of the Kernel by other projects
+ Emitter event.Emitter
+ Service rpc.Service
+ Launchers []process.Launcher
+ Logger logging_types.InfoTraceLogger
+ processes map[string]process.Process
+ shutdownNotify chan struct{}
+ shutdownOnce sync.Once
}
-func NewKernel(ctx context.Context, privValidator tm_types.PrivValidator, genesisDoc *genesis.GenesisDoc, tmConf *tm_config.Config,
- rpcConfig *rpc.RPCConfig, logger logging_types.InfoTraceLogger) (*Kernel, error) {
+func NewKernel(ctx context.Context, privValidator tm_types.PrivValidator, genesisDoc *genesis.GenesisDoc,
+ tmConf *tm_config.Config, rpcConfig *rpc.RPCConfig, logger logging_types.InfoTraceLogger) (*Kernel, error) {
logger = logging.WithScope(logger, "NewKernel")
-
+ var err error
stateDB := dbm.NewDB("burrow_state", dbm.GoLevelDBBackendStr, tmConf.DBDir())
- state, err := execution.MakeGenesisState(stateDB, genesisDoc)
+
+ blockchain, err := bcm.LoadOrNewBlockchain(stateDB, genesisDoc, logger)
if err != nil {
- return nil, fmt.Errorf("could not make genesis state: %v", err)
+ return nil, fmt.Errorf("error creating or loading blockchain state: %v", err)
}
- state.Save()
- blockchain := bcm.NewBlockchain(genesisDoc)
+ var state *execution.State
+ // These should be in sync unless we are at the genesis block
+ if blockchain.LastBlockHeight() > 0 {
+ state, err = execution.LoadState(stateDB, blockchain.AppHashAfterLastBlock())
+ if err != nil {
+ return nil, fmt.Errorf("could not load persisted execution state at hash 0x%X: %v",
+ blockchain.AppHashAfterLastBlock(), err)
+ }
+ } else {
+ state, err = execution.MakeGenesisState(stateDB, genesisDoc)
+ }
tmGenesisDoc := tendermint.DeriveGenesisDoc(genesisDoc)
checker := execution.NewBatchChecker(state, tmGenesisDoc.ChainID, blockchain, logger)
@@ -93,10 +104,20 @@ func NewKernel(ctx context.Context, privValidator tm_types.PrivValidator, genesi
// which increments the creator's account Sequence and SendTxs
service := rpc.NewService(ctx, state, state, emitter, blockchain, transactor, query.NewNodeView(tmNode, txCodec), logger)
- launchers := []server.Launcher{
+ launchers := []process.Launcher{
+ {
+ Name: "Database",
+ Launch: func() (process.Process, error) {
+ // Just close database
+ return process.ShutdownFunc(func(ctx context.Context) error {
+ stateDB.Close()
+ return nil
+ }), nil
+ },
+ },
{
Name: "Tendermint",
- Launch: func() (server.Server, error) {
+ Launch: func() (process.Process, error) {
err := tmNode.Start()
if err != nil {
return nil, fmt.Errorf("error starting Tendermint node: %v", err)
@@ -109,24 +130,37 @@ func NewKernel(ctx context.Context, privValidator tm_types.PrivValidator, genesi
if err != nil {
return nil, fmt.Errorf("could not subscribe to Tendermint events: %v", err)
}
- return server.ShutdownFunc(func(ctx context.Context) error {
- return tmNode.Stop()
+ return process.ShutdownFunc(func(ctx context.Context) error {
+ err := tmNode.Stop()
+ if err != nil {
+ return err
+ }
+ select {
+ case <-ctx.Done():
+ return ctx.Err()
+ case <-tmNode.Quit:
+ logging.InfoMsg(logger, "Tendermint Node has quit, closing DB connections...")
+ // Close tendermint database connections using our wrapper
+ tmNode.Close()
+ return nil
+ }
+ return err
}), nil
},
},
{
Name: "RPC/tm",
- Launch: func() (server.Server, error) {
+ Launch: func() (process.Process, error) {
listener, err := tm.StartServer(service, "/websocket", rpcConfig.TM.ListenAddress, emitter, logger)
if err != nil {
return nil, err
}
- return server.FromListeners(listener), nil
+ return process.FromListeners(listener), nil
},
},
{
Name: "RPC/V0",
- Launch: func() (server.Server, error) {
+ Launch: func() (process.Process, error) {
codec := v0.NewTCodec()
jsonServer := v0.NewJSONServer(v0.NewJSONService(codec, service, logger))
websocketServer := v0_server.NewWebSocketServer(rpcConfig.V0.Server.WebSocket.MaxWebSocketSessions,
@@ -146,24 +180,24 @@ func NewKernel(ctx context.Context, privValidator tm_types.PrivValidator, genesi
}
return &Kernel{
- emitter: emitter,
- service: service,
- serverLaunchers: launchers,
- servers: make(map[string]server.Server),
- logger: logger,
- shutdownNotify: make(chan struct{}),
+ Emitter: emitter,
+ Service: service,
+ Launchers: launchers,
+ processes: make(map[string]process.Process),
+ Logger: logger,
+ shutdownNotify: make(chan struct{}),
}, nil
}
// Boot the kernel starting Tendermint and RPC layers
func (kern *Kernel) Boot() error {
- for _, launcher := range kern.serverLaunchers {
+ for _, launcher := range kern.Launchers {
srvr, err := launcher.Launch()
if err != nil {
return fmt.Errorf("error launching %s server: %v", launcher.Name, err)
}
- kern.servers[launcher.Name] = srvr
+ kern.processes[launcher.Name] = srvr
}
go kern.supervise()
return nil
@@ -182,7 +216,7 @@ func (kern *Kernel) supervise() {
signals := make(chan os.Signal, 1)
signal.Notify(signals, syscall.SIGINT, syscall.SIGTERM, syscall.SIGKILL)
sig := <-signals
- logging.InfoMsg(kern.logger, fmt.Sprintf("Caught %v signal so shutting down", sig),
+ logging.InfoMsg(kern.Logger, fmt.Sprintf("Caught %v signal so shutting down", sig),
"signal", sig.String())
kern.Shutdown(context.Background())
}
@@ -190,15 +224,15 @@ func (kern *Kernel) supervise() {
// Stop the kernel allowing for a graceful shutdown of components in order
func (kern *Kernel) Shutdown(ctx context.Context) (err error) {
kern.shutdownOnce.Do(func() {
- logger := logging.WithScope(kern.logger, "Shutdown")
+ logger := logging.WithScope(kern.Logger, "Shutdown")
logging.InfoMsg(logger, "Attempting graceful shutdown...")
logging.InfoMsg(logger, "Shutting down servers")
ctx, cancel := context.WithTimeout(ctx, ServerShutdownTimeoutMilliseconds*time.Millisecond)
defer cancel()
// Shutdown servers in reverse order to boot
- for i := len(kern.serverLaunchers) - 1; i >= 0; i-- {
- name := kern.serverLaunchers[i].Name
- srvr, ok := kern.servers[name]
+ for i := len(kern.Launchers) - 1; i >= 0; i-- {
+ name := kern.Launchers[i].Name
+ srvr, ok := kern.processes[name]
if ok {
logging.InfoMsg(logger, "Shutting down server", "server_name", name)
sErr := srvr.Shutdown(ctx)
@@ -213,7 +247,7 @@ func (kern *Kernel) Shutdown(ctx context.Context) (err error) {
}
}
logging.InfoMsg(logger, "Shutdown complete")
- logging.Sync(kern.logger)
+ logging.Sync(kern.Logger)
// We don't want to wait for them, but yielding for a cooldown Let other goroutines flush
// potentially interesting final output (e.g. log messages)
time.Sleep(time.Millisecond * CooldownMilliseconds)
diff --git a/core/kernel_test.go b/core/kernel_test.go
index 0ff68e0f682b15983785e5da30ea7971a0435ddd..427461075c7118fd5dde4c3364168fa4abe599f0 100644
--- a/core/kernel_test.go
+++ b/core/kernel_test.go
@@ -5,12 +5,19 @@ import (
"os"
"testing"
+ "time"
+
+ "fmt"
+
+ "github.com/hyperledger/burrow/consensus/tendermint"
"github.com/hyperledger/burrow/consensus/tendermint/validator"
"github.com/hyperledger/burrow/genesis"
"github.com/hyperledger/burrow/logging/loggers"
+ logging_types "github.com/hyperledger/burrow/logging/types"
"github.com/hyperledger/burrow/rpc"
- "github.com/stretchr/testify/require"
+ "github.com/stretchr/testify/assert"
tm_config "github.com/tendermint/tendermint/config"
+ tm_types "github.com/tendermint/tendermint/types"
)
const testDir = "./test_scratch/kernel_test"
@@ -20,14 +27,70 @@ func TestBootThenShutdown(t *testing.T) {
os.MkdirAll(testDir, 0777)
os.Chdir(testDir)
tmConf := tm_config.DefaultConfig()
- //logger, _ := lifecycle.NewStdErrLogger()
+ //logger, _, _ := lifecycle.NewStdErrLogger()
logger := loggers.NewNoopInfoTraceLogger()
- genesisDoc, privateAccounts := genesis.NewDeterministicGenesis(123).GenesisDoc(1, true, 1000, 1, true, 1000)
- privValidator := validator.NewPrivValidatorMemory(privateAccounts[0], privateAccounts[0])
+ genesisDoc, _, privateValidators := genesis.NewDeterministicGenesis(123).GenesisDoc(1, true, 1000, 1, true, 1000)
+ privValidator := validator.NewPrivValidatorMemory(privateValidators[0], privateValidators[0])
+ assert.NoError(t, bootWaitBlocksShutdown(privValidator, genesisDoc, tmConf, logger, nil))
+}
+
+func TestBootShutdownResume(t *testing.T) {
+ os.RemoveAll(testDir)
+ os.MkdirAll(testDir, 0777)
+ os.Chdir(testDir)
+ tmConf := tm_config.DefaultConfig()
+ //logger, _, _ := lifecycle.NewStdErrLogger()
+ logger := loggers.NewNoopInfoTraceLogger()
+ genesisDoc, _, privateValidators := genesis.NewDeterministicGenesis(123).GenesisDoc(1, true, 1000, 1, true, 1000)
+ privValidator := validator.NewPrivValidatorMemory(privateValidators[0], privateValidators[0])
+
+ i := int64(1)
+ // asserts we get a consecutive run of blocks
+ blockChecker := func(block *tm_types.EventDataNewBlock) bool {
+ assert.Equal(t, i, block.Block.Height)
+ i++
+ // stop every third block
+ return i%3 != 0
+ }
+ // First run
+ assert.NoError(t, bootWaitBlocksShutdown(privValidator, genesisDoc, tmConf, logger, blockChecker))
+ // Resume and check we pick up where we left off
+ assert.NoError(t, bootWaitBlocksShutdown(privValidator, genesisDoc, tmConf, logger, blockChecker))
+ // Resuming with mismatched genesis should fail
+ genesisDoc.Salt = []byte("foo")
+ assert.Error(t, bootWaitBlocksShutdown(privValidator, genesisDoc, tmConf, logger, blockChecker))
+}
+
+func bootWaitBlocksShutdown(privValidator tm_types.PrivValidator, genesisDoc *genesis.GenesisDoc,
+ tmConf *tm_config.Config, logger logging_types.InfoTraceLogger,
+ blockChecker func(block *tm_types.EventDataNewBlock) (cont bool)) error {
+
kern, err := NewKernel(context.Background(), privValidator, genesisDoc, tmConf, rpc.DefaultRPCConfig(), logger)
- require.NoError(t, err)
+ if err != nil {
+ return err
+ }
+
err = kern.Boot()
- require.NoError(t, err)
- err = kern.Shutdown(context.Background())
- require.NoError(t, err)
+ if err != nil {
+ return err
+ }
+
+ ch := make(chan *tm_types.EventDataNewBlock)
+ tendermint.SubscribeNewBlock(context.Background(), kern.Emitter, "TestBootShutdownResume", ch)
+ cont := true
+ for cont {
+ select {
+ case <-time.After(2 * time.Second):
+ if err != nil {
+ return fmt.Errorf("timed out waiting for block")
+ }
+ case ednb := <-ch:
+ if blockChecker == nil {
+ cont = false
+ } else {
+ cont = blockChecker(ednb)
+ }
+ }
+ }
+ return kern.Shutdown(context.Background())
}
diff --git a/event/emitter.go b/event/emitter.go
index 73996b7c8fe54055a7343d9b80a7e99c06858f71..d41d0fd1b30a4a798db16f000bd099f17fc17f81 100644
--- a/event/emitter.go
+++ b/event/emitter.go
@@ -23,7 +23,7 @@ import (
"github.com/hyperledger/burrow/logging/structure"
logging_types "github.com/hyperledger/burrow/logging/types"
- "github.com/hyperledger/burrow/server"
+ "github.com/hyperledger/burrow/process"
"github.com/tendermint/tmlibs/common"
"github.com/tendermint/tmlibs/pubsub"
)
@@ -45,7 +45,7 @@ type Publisher interface {
type Emitter interface {
Subscribable
Publisher
- server.Server
+ process.Process
}
// The events struct has methods for working with events.
diff --git a/execution/block_cache.go b/execution/block_cache.go
deleted file mode 100644
index 7f1a240306be7945ec627d4043f879a4726278de..0000000000000000000000000000000000000000
--- a/execution/block_cache.go
+++ /dev/null
@@ -1,384 +0,0 @@
-// Copyright 2017 Monax Industries Limited
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package execution
-
-import (
- "bytes"
- "fmt"
- "sort"
- "sync"
-
- acm "github.com/hyperledger/burrow/account"
- . "github.com/hyperledger/burrow/binary"
- "github.com/tendermint/merkleeyes/iavl"
- dbm "github.com/tendermint/tmlibs/db"
- "github.com/tendermint/tmlibs/merkle"
-)
-
-func makeStorage(db dbm.DB, root []byte) merkle.Tree {
- storage := iavl.NewIAVLTree(1024, db)
- storage.Load(root)
- return storage
-}
-
-var _ acm.StateWriter = &BlockCache{}
-
-var _ acm.StateIterable = &BlockCache{}
-
-// TODO: BlockCache badly needs a rewrite to remove database sharing with State and make it communicate using the
-// Account interfaces like a proper person. As well as other oddities of decoupled storage and account state
-
-// The blockcache helps prevent unnecessary IAVLTree updates and garbage generation.
-type BlockCache struct {
- // We currently provide the RPC layer with access to read-only access to BlockCache via the StateIterable interface
- // on BatchExecutor. However since read-only operations generate writes to the BlockCache in the current design
- // we need a mutex here. Otherwise BlockCache ought to be used within a component that is responsible for serialising
- // the operations on the BlockCache.
- sync.RWMutex
- db dbm.DB
- backend *State
- accounts map[acm.Address]accountInfo
- storages map[acm.Address]map[Word256]storageInfo
- names map[string]nameInfo
-}
-
-func NewBlockCache(backend *State) *BlockCache {
- return &BlockCache{
- // TODO: This is bad and probably the cause of various panics. Accounts themselves are written
- // to the State 'backend' but updates to storage just skip that and write directly to the database
- db: backend.db,
- backend: backend,
- accounts: make(map[acm.Address]accountInfo),
- storages: make(map[acm.Address]map[Word256]storageInfo),
- names: make(map[string]nameInfo),
- }
-}
-
-func (cache *BlockCache) State() *State {
- return cache.backend
-}
-
-//-------------------------------------
-// BlockCache.account
-
-func (cache *BlockCache) GetAccount(addr acm.Address) (acm.Account, error) {
- acc, _, removed, _ := cache.accounts[addr].unpack()
- if removed {
- return nil, nil
- } else if acc != nil {
- return acc, nil
- } else {
- acc, err := cache.backend.GetAccount(addr)
- if err != nil {
- return nil, err
- }
- cache.Lock()
- defer cache.Unlock()
- cache.accounts[addr] = accountInfo{acc, nil, false, false}
- return acc, nil
- }
-}
-
-func (cache *BlockCache) UpdateAccount(acc acm.Account) error {
- cache.Lock()
- defer cache.Unlock()
- addr := acc.Address()
- _, storage, removed, _ := cache.accounts[addr].unpack()
- if removed {
- return fmt.Errorf("UpdateAccount on a removed account %s", addr)
- }
- cache.accounts[addr] = accountInfo{acc, storage, false, true}
- return nil
-}
-
-func (cache *BlockCache) RemoveAccount(addr acm.Address) error {
- cache.Lock()
- defer cache.Unlock()
- _, _, removed, _ := cache.accounts[addr].unpack()
- if removed {
- return fmt.Errorf("RemoveAccount on a removed account %s", addr)
- }
- cache.accounts[addr] = accountInfo{nil, nil, true, false}
- return nil
-}
-
-func (cache *BlockCache) IterateAccounts(consumer func(acm.Account) (stop bool)) (bool, error) {
- cache.RLock()
- defer cache.RUnlock()
- for _, info := range cache.accounts {
- if consumer(info.account) {
- return true, nil
- }
- }
- return cache.backend.IterateAccounts(consumer)
-}
-
-// BlockCache.account
-//-------------------------------------
-// BlockCache.storage
-
-func (cache *BlockCache) GetStorage(addr acm.Address, key Word256) (Word256, error) {
- // Check cache
- cache.RLock()
- info, ok := cache.lookupStorage(addr, key)
- cache.RUnlock()
- if ok {
- return info.value, nil
- }
- // Get or load storage
- cache.RLock()
- acc, storage, removed, dirty := cache.accounts[addr].unpack()
- cache.RUnlock()
- if removed {
- return Zero256, fmt.Errorf("GetStorage on a removed account %s", addr)
- }
- cache.Lock()
- defer cache.Unlock()
-
- if acc != nil && storage == nil {
- storage = makeStorage(cache.db, acc.StorageRoot())
- cache.accounts[addr] = accountInfo{acc, storage, false, dirty}
- } else if acc == nil {
- return Zero256, nil
- }
- // Load and set cache
- _, val, _ := storage.Get(key.Bytes())
- value := LeftPadWord256(val)
- cache.setStorage(addr, key, storageInfo{value, false})
- return value, nil
-}
-
-// NOTE: Set value to zero to removed from the trie.
-func (cache *BlockCache) SetStorage(addr acm.Address, key Word256, value Word256) error {
- cache.Lock()
- defer cache.Unlock()
- _, _, removed, _ := cache.accounts[addr].unpack()
- if removed {
- return fmt.Errorf("SetStorage on a removed account %s", addr)
- }
- cache.setStorage(addr, key, storageInfo{value, true})
- return nil
-}
-
-func (cache *BlockCache) IterateStorage(address acm.Address, consumer func(key, value Word256) (stop bool)) (bool, error) {
- cache.RLock()
- defer cache.RUnlock()
- // Try cache first for early exit
- for key, info := range cache.storages[address] {
- if consumer(key, info.value) {
- return true, nil
- }
- }
-
- return cache.backend.IterateStorage(address, consumer)
-}
-
-// BlockCache.storage
-//-------------------------------------
-// BlockCache.names
-
-func (cache *BlockCache) GetNameRegEntry(name string) *NameRegEntry {
- cache.RLock()
- entry, removed, _ := cache.names[name].unpack()
- cache.RUnlock()
- if removed {
- return nil
- } else if entry != nil {
- return entry
- } else {
- entry = cache.backend.GetNameRegEntry(name)
- cache.Lock()
- cache.names[name] = nameInfo{entry, false, false}
- cache.Unlock()
- return entry
- }
-}
-
-func (cache *BlockCache) UpdateNameRegEntry(entry *NameRegEntry) {
- cache.Lock()
- defer cache.Unlock()
- cache.names[entry.Name] = nameInfo{entry, false, true}
-}
-
-func (cache *BlockCache) RemoveNameRegEntry(name string) {
- cache.Lock()
- defer cache.Unlock()
- _, removed, _ := cache.names[name].unpack()
- if removed {
- panic("RemoveNameRegEntry on a removed entry")
- }
- cache.names[name] = nameInfo{nil, true, false}
-}
-
-// BlockCache.names
-//-------------------------------------
-
-// CONTRACT the updates are in deterministic order.
-func (cache *BlockCache) Sync() {
- cache.Lock()
- defer cache.Unlock()
- // Determine order for storage updates
- // The address comes first so it'll be grouped.
- storageKeys := make([]Tuple256, 0, len(cache.storages))
- for address, keyInfoMap := range cache.storages {
- for key, _ := range keyInfoMap {
- storageKeys = append(storageKeys, Tuple256{First: address.Word256(), Second: key})
- }
- }
- Tuple256Slice(storageKeys).Sort()
-
- // Update storage for all account/key.
- // Later we'll iterate over all the users and save storage + update storage root.
- var (
- curAddr acm.Address
- curAcc acm.Account
- curAccRemoved bool
- curStorage merkle.Tree
- )
- for _, storageKey := range storageKeys {
- addrWord256, key := Tuple256Split(storageKey)
- addr := acm.AddressFromWord256(addrWord256)
- if addr != curAddr || curAcc == nil {
- acc, storage, removed, _ := cache.accounts[addr].unpack()
- if !removed && storage == nil {
- storage = makeStorage(cache.db, acc.StorageRoot())
- }
- curAddr = addr
- curAcc = acc
- curAccRemoved = removed
- curStorage = storage
- }
- if curAccRemoved {
- continue
- }
- value, dirty := cache.storages[acm.AddressFromWord256(storageKey.First)][storageKey.Second].unpack()
- if !dirty {
- continue
- }
- if value.IsZero() {
- curStorage.Remove(key.Bytes())
- } else {
- curStorage.Set(key.Bytes(), value.Bytes())
- cache.accounts[addr] = accountInfo{curAcc, curStorage, false, true}
- }
- }
-
- // Determine order for accounts
- addrs := []acm.Address{}
- for addr := range cache.accounts {
- addrs = append(addrs, addr)
- }
- sort.Slice(addrs, func(i, j int) bool {
- return addrs[i].String() < addrs[j].String()
- })
-
- // Update or delete accounts.
- for _, addr := range addrs {
- acc, storage, removed, dirty := cache.accounts[addr].unpack()
- if removed {
- cache.backend.RemoveAccount(addr)
- } else {
- if acc == nil {
- continue
- }
- if storage != nil {
- newStorageRoot := storage.Save()
- if !bytes.Equal(newStorageRoot, acc.StorageRoot()) {
- acc = acm.AsMutableAccount(acc).SetStorageRoot(newStorageRoot)
- dirty = true
- }
- }
- if dirty {
- cache.backend.UpdateAccount(acc)
- }
- }
- }
-
- // Determine order for names
- // note names may be of any length less than some limit
- nameStrs := []string{}
- for nameStr := range cache.names {
- nameStrs = append(nameStrs, nameStr)
- }
- sort.Strings(nameStrs)
-
- // Update or delete names.
- for _, nameStr := range nameStrs {
- entry, removed, dirty := cache.names[nameStr].unpack()
- if removed {
- removed := cache.backend.RemoveNameRegEntry(nameStr)
- if !removed {
- panic(fmt.Sprintf("Could not remove namereg entry to be removed: %s", nameStr))
- }
- } else {
- if entry == nil {
- continue
- }
- if dirty {
- cache.backend.UpdateNameRegEntry(entry)
- }
- }
- }
-}
-
-func (cache *BlockCache) lookupStorage(address acm.Address, key Word256) (storageInfo, bool) {
- keyInfoMap, ok := cache.storages[address]
- if !ok {
- return storageInfo{}, false
- }
- info, ok := keyInfoMap[key]
- return info, ok
-}
-
-func (cache *BlockCache) setStorage(address acm.Address, key Word256, info storageInfo) {
- keyInfoMap, ok := cache.storages[address]
- if !ok {
- keyInfoMap = make(map[Word256]storageInfo)
- cache.storages[address] = keyInfoMap
- }
- keyInfoMap[key] = info
-}
-
-//-----------------------------------------------------------------------------
-
-type accountInfo struct {
- account acm.Account
- storage merkle.Tree
- removed bool
- dirty bool
-}
-
-func (accInfo accountInfo) unpack() (acm.Account, merkle.Tree, bool, bool) {
- return accInfo.account, accInfo.storage, accInfo.removed, accInfo.dirty
-}
-
-type storageInfo struct {
- value Word256
- dirty bool
-}
-
-func (stjInfo storageInfo) unpack() (Word256, bool) {
- return stjInfo.value, stjInfo.dirty
-}
-
-type nameInfo struct {
- name *NameRegEntry
- removed bool
- dirty bool
-}
-
-func (nInfo nameInfo) unpack() (*NameRegEntry, bool, bool) {
- return nInfo.name, nInfo.removed, nInfo.dirty
-}
diff --git a/execution/evm/accounts.go b/execution/evm/accounts.go
index 19735838ae9c771a58bc4c4ff6d1d2cfe2d5808a..618557aaa9aabca3d6f4982ce81ad793f5838521 100644
--- a/execution/evm/accounts.go
+++ b/execution/evm/accounts.go
@@ -2,14 +2,22 @@ package evm
import (
acm "github.com/hyperledger/burrow/account"
+ "github.com/hyperledger/burrow/logging"
+ logging_types "github.com/hyperledger/burrow/logging/types"
ptypes "github.com/hyperledger/burrow/permission/types"
)
// Create a new account from a parent 'creator' account. The creator account will have its
// sequence number incremented
-func DeriveNewAccount(creator acm.MutableAccount, permissions ptypes.AccountPermissions) acm.MutableAccount {
+func DeriveNewAccount(creator acm.MutableAccount, permissions ptypes.AccountPermissions,
+ logger logging_types.InfoTraceLogger) acm.MutableAccount {
// Generate an address
sequence := creator.Sequence()
+ logging.TraceMsg(logger, "Incrementing sequence number in DeriveNewAccount()",
+ "tag", "sequence",
+ "account", creator.Address(),
+ "old_sequence", sequence,
+ "new_sequence", sequence+1)
creator.IncSequence()
addr := acm.NewContractAddress(creator.Address(), sequence)
diff --git a/execution/evm/vm.go b/execution/evm/vm.go
index fe1f51cbfde5783612babd698940888874609e0a..98fd2943281ce862ed1bdcda0e7fc60eb811dd19 100644
--- a/execution/evm/vm.go
+++ b/execution/evm/vm.go
@@ -72,7 +72,7 @@ type VM struct {
memoryProvider func() Memory
params Params
origin acm.Address
- txid []byte
+ txHash []byte
callDepth int
publisher event.Publisher
logger logging_types.InfoTraceLogger
@@ -86,7 +86,7 @@ func NewVM(state acm.StateWriter, memoryProvider func() Memory, params Params, o
params: params,
origin: origin,
callDepth: 0,
- txid: txid,
+ txHash: txid,
logger: logging.WithScope(logger, "NewVM"),
}
}
@@ -117,7 +117,7 @@ func (vm *VM) fireCallEvent(exception *string, output *[]byte, callerAddress, ca
events.PublishAccountCall(vm.publisher, calleeAddress, &events.EventDataCall{
&events.CallData{Caller: callerAddress, Callee: calleeAddress, Data: input, Value: value, Gas: *gas},
vm.origin,
- vm.txid,
+ vm.txHash,
*output,
*exception,
})
@@ -746,7 +746,8 @@ func (vm *VM) call(caller, callee acm.MutableAccount, code, input []byte, value
}
// TODO charge for gas to create account _ the code length * GasCreateByte
- newAccount := DeriveNewAccount(callee, permission.GlobalAccountPermissions(vm.state))
+ newAccount := DeriveNewAccount(callee, permission.GlobalAccountPermissions(vm.state),
+ vm.logger.With("tx_hash", vm.txHash))
vm.state.UpdateAccount(newAccount)
// Run the input to get the contract code.
diff --git a/execution/execution.go b/execution/execution.go
index 2f0c243f491bb0d48e288dc069d27010369fa3b1..fbe69f4f4fdddacd6e9d2bc68bcfe03d08b91098 100644
--- a/execution/execution.go
+++ b/execution/execution.go
@@ -32,6 +32,9 @@ import (
"github.com/hyperledger/burrow/txs"
)
+// TODO
+const GasLimit = uint64(1000000)
+
type BatchExecutor interface {
acm.StateIterable
acm.Updater
@@ -51,15 +54,16 @@ type BatchCommitter interface {
}
type executor struct {
- mtx sync.Mutex
- chainID string
- tip bcm.Tip
- runCall bool
- state *State
- blockCache *BlockCache
- publisher event.Publisher
- eventCache *event.Cache
- logger logging_types.InfoTraceLogger
+ sync.Mutex
+ chainID string
+ tip bcm.Tip
+ runCall bool
+ state *State
+ stateCache acm.StateCache
+ nameRegCache *NameRegCache
+ publisher event.Publisher
+ eventCache *event.Cache
+ logger logging_types.InfoTraceLogger
}
var _ BatchExecutor = (*executor)(nil)
@@ -89,62 +93,78 @@ func newExecutor(runCall bool,
eventFireable event.Publisher,
logger logging_types.InfoTraceLogger) *executor {
return &executor{
- chainID: chainID,
- tip: tip,
- runCall: runCall,
- state: state,
- blockCache: NewBlockCache(state),
- publisher: eventFireable,
- eventCache: event.NewEventCache(eventFireable),
- logger: logger.With(structure.ComponentKey, "Execution"),
+ chainID: chainID,
+ tip: tip,
+ runCall: runCall,
+ state: state,
+ stateCache: acm.NewStateCache(state),
+ nameRegCache: NewNameRegCache(state),
+ publisher: eventFireable,
+ eventCache: event.NewEventCache(eventFireable),
+ logger: logger.With(structure.ComponentKey, "Executor"),
}
}
// Accounts
func (exe *executor) GetAccount(address acm.Address) (acm.Account, error) {
- return exe.blockCache.GetAccount(address)
+ return exe.stateCache.GetAccount(address)
}
func (exe *executor) UpdateAccount(account acm.Account) error {
- return exe.blockCache.UpdateAccount(account)
+ return exe.stateCache.UpdateAccount(account)
}
func (exe *executor) RemoveAccount(address acm.Address) error {
- return exe.blockCache.RemoveAccount(address)
+ return exe.stateCache.RemoveAccount(address)
}
func (exe *executor) IterateAccounts(consumer func(acm.Account) bool) (bool, error) {
- return exe.blockCache.IterateAccounts(consumer)
+ return exe.stateCache.IterateAccounts(consumer)
}
// Storage
func (exe *executor) GetStorage(address acm.Address, key binary.Word256) (binary.Word256, error) {
- return exe.blockCache.GetStorage(address, key)
+ return exe.stateCache.GetStorage(address, key)
}
func (exe *executor) SetStorage(address acm.Address, key binary.Word256, value binary.Word256) error {
- return exe.blockCache.SetStorage(address, key, value)
+ return exe.stateCache.SetStorage(address, key, value)
}
func (exe *executor) IterateStorage(address acm.Address, consumer func(key, value binary.Word256) bool) (bool, error) {
- return exe.blockCache.IterateStorage(address, consumer)
+ return exe.stateCache.IterateStorage(address, consumer)
}
-func (exe *executor) Commit() ([]byte, error) {
- exe.mtx.Lock()
- defer exe.mtx.Unlock()
- // sync the cache
- exe.blockCache.Sync()
+func (exe *executor) Commit() (hash []byte, err error) {
+ exe.Lock()
+ defer exe.Unlock()
+ defer func() {
+ if r := recover(); r != nil {
+ err = fmt.Errorf("recovered from panic in executor.Commit(): %v", r)
+ }
+ }()
+ // flush the caches
+ err = exe.stateCache.Flush(exe.state)
+ if err != nil {
+ return nil, err
+ }
+ err = exe.nameRegCache.Flush(exe.state)
+ if err != nil {
+ return nil, err
+ }
// save state to disk
- exe.state.Save()
+ err = exe.state.Save()
+ if err != nil {
+ return nil, err
+ }
// flush events to listeners (XXX: note issue with blocking)
exe.eventCache.Flush()
return exe.state.Hash(), nil
}
func (exe *executor) Reset() error {
- exe.blockCache = NewBlockCache(exe.state)
- exe.eventCache = event.NewEventCache(exe.publisher)
+ exe.stateCache.Reset(exe.state)
+ exe.nameRegCache.Reset(exe.state)
return nil
}
@@ -156,7 +176,12 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
err = fmt.Errorf("recovered from panic in executor.Execute(%s): %v", tx.String(), r)
}
}()
- logger := logging.WithScope(exe.logger, "executor.Execute(tx txs.Tx)")
+
+ txHash := tx.Hash(exe.chainID)
+ logger := logging.WithScope(exe.logger, "executor.Execute(tx txs.Tx)").With(
+ "run_call", exe.runCall,
+ "tx", tx.String(),
+ "tx_hash", txHash)
logging.TraceMsg(logger, "Executing transaction", "tx", tx.String())
// TODO: do something with fees
fees := uint64(0)
@@ -164,19 +189,19 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
// Exec tx
switch tx := tx.(type) {
case *txs.SendTx:
- accounts, err := getInputs(exe.blockCache, tx.Inputs)
+ accounts, err := getInputs(exe.stateCache, tx.Inputs)
if err != nil {
return err
}
// ensure all inputs have send permissions
- if !hasSendPermission(exe.blockCache, accounts, logger) {
+ if !hasSendPermission(exe.stateCache, accounts, logger) {
return fmt.Errorf("at least one input lacks permission for SendTx")
}
// add outputs to accounts map
// if any outputs don't exist, all inputs must have CreateAccount perm
- accounts, err = getOrMakeOutputs(exe.blockCache, accounts, tx.Outputs, logger)
+ accounts, err = getOrMakeOutputs(exe.stateCache, accounts, tx.Outputs, logger)
if err != nil {
return err
}
@@ -197,7 +222,7 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
fees += fee
// Good! Adjust accounts
- err = adjustByInputs(accounts, tx.Inputs)
+ err = adjustByInputs(accounts, tx.Inputs, logger)
if err != nil {
return err
}
@@ -208,12 +233,11 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
}
for _, acc := range accounts {
- exe.blockCache.UpdateAccount(acc)
+ exe.stateCache.UpdateAccount(acc)
}
// if the exe.eventCache is nil, nothing will happen
if exe.eventCache != nil {
- txHash := txs.TxHash(exe.chainID, tx)
for _, i := range tx.Inputs {
events.PublishAccountInput(exe.eventCache, i.Address, txHash, tx, nil, "")
}
@@ -229,7 +253,7 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
var outAcc acm.Account
// Validate input
- inAcc, err := acm.GetMutableAccount(exe.blockCache, tx.Input.Address)
+ inAcc, err := acm.GetMutableAccount(exe.stateCache, tx.Input.Address)
if err != nil {
return err
}
@@ -241,11 +265,11 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
createContract := tx.Address == nil
if createContract {
- if !hasCreateContractPermission(exe.blockCache, inAcc, logger) {
+ if !hasCreateContractPermission(exe.stateCache, inAcc, logger) {
return fmt.Errorf("account %s does not have CreateContract permission", tx.Input.Address)
}
} else {
- if !hasCallPermission(exe.blockCache, inAcc, logger) {
+ if !hasCallPermission(exe.stateCache, inAcc, logger) {
return fmt.Errorf("account %s does not have Call permission", tx.Input.Address)
}
}
@@ -282,7 +306,7 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
// but that's fine, because the account will be created properly when the create tx runs in the block
// and then this won't return nil. otherwise, we take their fee
// Note: tx.Address == nil iff createContract so dereference is okay
- outAcc, err = exe.blockCache.GetAccount(*tx.Address)
+ outAcc, err = exe.stateCache.GetAccount(*tx.Address)
if err != nil {
return err
}
@@ -293,7 +317,8 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
// Good!
value := tx.Input.Amount - tx.Fee
- logging.TraceMsg(logger, "Incrementing sequence number",
+ logging.TraceMsg(logger, "Incrementing sequence number for CallTx",
+ "tag", "sequence",
"account", inAcc.Address(),
"old_sequence", inAcc.Sequence(),
"new_sequence", inAcc.Sequence()+1)
@@ -303,7 +328,7 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
return err
}
- exe.blockCache.UpdateAccount(inAcc)
+ exe.stateCache.UpdateAccount(inAcc)
// The logic in runCall MUST NOT return.
if exe.runCall {
@@ -315,7 +340,7 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
callee acm.MutableAccount = nil // initialized below
code []byte = nil
ret []byte = nil
- txCache = NewTxCache(exe.blockCache)
+ txCache = acm.NewStateCache(exe.stateCache)
params = evm.Params{
BlockHeight: exe.tip.LastBlockHeight(),
BlockHash: binary.LeftPadWord256(exe.tip.LastBlockHash()),
@@ -348,7 +373,12 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
// get or create callee
if createContract {
// We already checked for permission
- callee = evm.DeriveNewAccount(caller, permission.GlobalAccountPermissions(exe.state))
+ callee = evm.DeriveNewAccount(caller, permission.GlobalAccountPermissions(exe.state),
+ logger.With(
+ "tx", tx.String(),
+ "tx_hash", txHash,
+ "run_call", exe.runCall,
+ ))
code = tx.Data
logging.TraceMsg(logger, "Creating new contract",
"contract_address", callee.Address(),
@@ -369,7 +399,7 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
txCache.UpdateAccount(caller)
txCache.UpdateAccount(callee)
vmach := evm.NewVM(txCache, evm.DefaultDynamicMemoryProvider, params, caller.Address(),
- txs.TxHash(exe.chainID, tx), logger)
+ tx.Hash(exe.chainID), logger)
vmach.SetPublisher(exe.eventCache)
// NOTE: Call() transfers the value from caller to callee iff call succeeds.
ret, err = vmach.Call(caller, callee, code, tx.Data, value, &gas)
@@ -384,7 +414,7 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
if createContract {
callee.SetCode(ret)
}
- txCache.Sync(exe.blockCache)
+ txCache.Sync(exe.stateCache)
}
CALL_COMPLETE: // err may or may not be nil.
@@ -403,7 +433,7 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
if err != nil {
exception = err.Error()
}
- txHash := txs.TxHash(exe.chainID, tx)
+ txHash := tx.Hash(exe.chainID)
events.PublishAccountInput(exe.eventCache, tx.Input.Address, txHash, tx, ret, exception)
if tx.Address != nil {
events.PublishAccountOutput(exe.eventCache, *tx.Address, txHash, tx, ret, exception)
@@ -420,21 +450,21 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
}
if createContract {
// This is done by DeriveNewAccount when runCall == true
-
logging.TraceMsg(logger, "Incrementing sequence number since creates contract",
+ "tag", "sequence",
"account", inAcc.Address(),
"old_sequence", inAcc.Sequence(),
"new_sequence", inAcc.Sequence()+1)
inAcc.IncSequence()
}
- exe.blockCache.UpdateAccount(inAcc)
+ exe.stateCache.UpdateAccount(inAcc)
}
return nil
case *txs.NameTx:
// Validate input
- inAcc, err := acm.GetMutableAccount(exe.blockCache, tx.Input.Address)
+ inAcc, err := acm.GetMutableAccount(exe.stateCache, tx.Input.Address)
if err != nil {
return err
}
@@ -444,7 +474,7 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
return txs.ErrTxInvalidAddress
}
// check permission
- if !hasNamePermission(exe.blockCache, inAcc, logger) {
+ if !hasNamePermission(exe.stateCache, inAcc, logger) {
return fmt.Errorf("account %s does not have Name permission", tx.Input.Address)
}
// pubKey should be present in either "inAcc" or "tx.Input"
@@ -485,7 +515,10 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
"last_block_height", lastBlockHeight)
// check if the name exists
- entry := exe.blockCache.GetNameRegEntry(tx.Name)
+ entry, err := exe.nameRegCache.GetNameRegEntry(tx.Name)
+ if err != nil {
+ return err
+ }
if entry != nil {
var expired bool
@@ -507,7 +540,10 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
// (owners if not expired, anyone if expired)
logging.TraceMsg(logger, "Removing NameReg entry (no value and empty data in tx requests this)",
"name", entry.Name)
- exe.blockCache.RemoveNameRegEntry(entry.Name)
+ err := exe.nameRegCache.RemoveNameRegEntry(entry.Name)
+ if err != nil {
+ return err
+ }
} else {
// update the entry by bumping the expiry
// and changing the data
@@ -539,7 +575,10 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
"credit", credit)
}
entry.Data = tx.Data
- exe.blockCache.UpdateNameRegEntry(entry)
+ err := exe.nameRegCache.UpdateNameRegEntry(entry)
+ if err != nil {
+ return err
+ }
}
} else {
if expiresIn < txs.MinNameRegistrationPeriod {
@@ -555,23 +594,31 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
logging.TraceMsg(logger, "Creating NameReg entry",
"name", entry.Name,
"expires_in", expiresIn)
- exe.blockCache.UpdateNameRegEntry(entry)
+ err := exe.nameRegCache.UpdateNameRegEntry(entry)
+ if err != nil {
+ return err
+ }
}
// TODO: something with the value sent?
// Good!
+ logging.TraceMsg(logger, "Incrementing sequence number for NameTx",
+ "tag", "sequence",
+ "account", inAcc.Address(),
+ "old_sequence", inAcc.Sequence(),
+ "new_sequence", inAcc.Sequence()+1)
inAcc.IncSequence()
inAcc, err = inAcc.SubtractFromBalance(value)
if err != nil {
return err
}
- exe.blockCache.UpdateAccount(inAcc)
+ exe.stateCache.UpdateAccount(inAcc)
// TODO: maybe we want to take funds on error and allow txs in that don't do anythingi?
if exe.eventCache != nil {
- txHash := txs.TxHash(exe.chainID, tx)
+ txHash := tx.Hash(exe.chainID)
events.PublishAccountInput(exe.eventCache, tx.Input.Address, txHash, tx, nil, "")
events.PublishNameReg(exe.eventCache, txHash, tx)
}
@@ -719,7 +766,7 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
case *txs.PermissionsTx:
// Validate input
- inAcc, err := acm.GetMutableAccount(exe.blockCache, tx.Input.Address)
+ inAcc, err := acm.GetMutableAccount(exe.stateCache, tx.Input.Address)
if err != nil {
return err
}
@@ -736,7 +783,7 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
permFlag := tx.PermArgs.PermFlag
// check permission
- if !HasPermission(exe.blockCache, inAcc, permFlag, logger) {
+ if !HasPermission(exe.stateCache, inAcc, permFlag, logger) {
return fmt.Errorf("account %s does not have moderator permission %s (%b)", tx.Input.Address,
permission.PermFlagToString(permFlag), permFlag)
}
@@ -767,24 +814,24 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
// this one doesn't make sense from txs
return fmt.Errorf("HasBase is for contracts, not humans. Just look at the blockchain")
case permission.SetBase:
- permAcc, err = mutatePermissions(exe.blockCache, *tx.PermArgs.Address,
+ permAcc, err = mutatePermissions(exe.stateCache, *tx.PermArgs.Address,
func(perms *ptypes.AccountPermissions) error {
return perms.Base.Set(*tx.PermArgs.Permission, *tx.PermArgs.Value)
})
case permission.UnsetBase:
- permAcc, err = mutatePermissions(exe.blockCache, *tx.PermArgs.Address,
+ permAcc, err = mutatePermissions(exe.stateCache, *tx.PermArgs.Address,
func(perms *ptypes.AccountPermissions) error {
return perms.Base.Unset(*tx.PermArgs.Permission)
})
case permission.SetGlobal:
- permAcc, err = mutatePermissions(exe.blockCache, permission.GlobalPermissionsAddress,
+ permAcc, err = mutatePermissions(exe.stateCache, permission.GlobalPermissionsAddress,
func(perms *ptypes.AccountPermissions) error {
return perms.Base.Set(*tx.PermArgs.Permission, *tx.PermArgs.Value)
})
case permission.HasRole:
return fmt.Errorf("HasRole is for contracts, not humans. Just look at the blockchain")
case permission.AddRole:
- permAcc, err = mutatePermissions(exe.blockCache, *tx.PermArgs.Address,
+ permAcc, err = mutatePermissions(exe.stateCache, *tx.PermArgs.Address,
func(perms *ptypes.AccountPermissions) error {
if !perms.AddRole(*tx.PermArgs.Role) {
return fmt.Errorf("role (%s) already exists for account %s",
@@ -793,7 +840,7 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
return nil
})
case permission.RemoveRole:
- permAcc, err = mutatePermissions(exe.blockCache, *tx.PermArgs.Address,
+ permAcc, err = mutatePermissions(exe.stateCache, *tx.PermArgs.Address,
func(perms *ptypes.AccountPermissions) error {
if !perms.RmRole(*tx.PermArgs.Role) {
return fmt.Errorf("role (%s) does not exist for account %s",
@@ -811,18 +858,23 @@ func (exe *executor) Execute(tx txs.Tx) (err error) {
}
// Good!
+ logging.TraceMsg(logger, "Incrementing sequence number for PermissionsTx",
+ "tag", "sequence",
+ "account", inAcc.Address(),
+ "old_sequence", inAcc.Sequence(),
+ "new_sequence", inAcc.Sequence()+1)
inAcc.IncSequence()
inAcc, err = inAcc.SubtractFromBalance(value)
if err != nil {
return err
}
- exe.blockCache.UpdateAccount(inAcc)
+ exe.stateCache.UpdateAccount(inAcc)
if permAcc != nil {
- exe.blockCache.UpdateAccount(permAcc)
+ exe.stateCache.UpdateAccount(permAcc)
}
if exe.eventCache != nil {
- txHash := txs.TxHash(exe.chainID, tx)
+ txHash := tx.Hash(exe.chainID)
events.PublishAccountInput(exe.eventCache, tx.Input.Address, txHash, tx, nil, "")
events.PublishPermissions(exe.eventCache, permission.PermFlagToString(permFlag), txHash, tx)
}
@@ -1121,7 +1173,7 @@ func validateOutputs(outs []*txs.TxOutput) (uint64, error) {
return total, nil
}
-func adjustByInputs(accs map[acm.Address]acm.MutableAccount, ins []*txs.TxInput) error {
+func adjustByInputs(accs map[acm.Address]acm.MutableAccount, ins []*txs.TxInput, logger logging_types.InfoTraceLogger) error {
for _, in := range ins {
acc := accs[in.Address]
if acc == nil {
@@ -1136,6 +1188,11 @@ func adjustByInputs(accs map[acm.Address]acm.MutableAccount, ins []*txs.TxInput)
if err != nil {
return err
}
+ logging.TraceMsg(logger, "Incrementing sequence number for SendTx (adjustByInputs)",
+ "tag", "sequence",
+ "account", acc.Address(),
+ "old_sequence", acc.Sequence(),
+ "new_sequence", acc.Sequence()+1)
acc.IncSequence()
}
return nil
diff --git a/execution/execution_test.go b/execution/execution_test.go
index 2362c3f4ab23285da8a9739348ca69cced3190fc..47e913ce9e727a98a0a835a18a6491be7f23c13a 100644
--- a/execution/execution_test.go
+++ b/execution/execution_test.go
@@ -31,6 +31,7 @@ import (
. "github.com/hyperledger/burrow/execution/evm/asm"
"github.com/hyperledger/burrow/execution/evm/asm/bc"
evm_events "github.com/hyperledger/burrow/execution/evm/events"
+ "github.com/hyperledger/burrow/execution/evm/sha3"
"github.com/hyperledger/burrow/genesis"
"github.com/hyperledger/burrow/logging/loggers"
"github.com/hyperledger/burrow/permission"
@@ -38,10 +39,11 @@ import (
"github.com/hyperledger/burrow/txs"
"github.com/stretchr/testify/require"
dbm "github.com/tendermint/tmlibs/db"
+ "github.com/tmthrgd/go-hex"
)
var (
- dbBackend = "memdb"
+ dbBackend = dbm.MemDBBackendStr
dbDir = ""
permissionsContract = evm.SNativeContracts()["Permissions"]
)
@@ -110,6 +112,10 @@ x - roles: has, add, rm
// keys
var users = makeUsers(10)
var logger = loggers.NewNoopInfoTraceLogger()
+var deterministicGenesis = genesis.NewDeterministicGenesis(34059836243380576)
+var testGenesisDoc, testPrivAccounts, _ = deterministicGenesis.
+ GenesisDoc(3, true, 1000, 1, true, 1000)
+var testChainID = testGenesisDoc.ChainID()
func makeUsers(n int) []acm.PrivateAccount {
users := make([]acm.PrivateAccount, n)
@@ -121,7 +127,7 @@ func makeUsers(n int) []acm.PrivateAccount {
}
func makeExecutor(state *State) *executor {
- return newExecutor(true, state, testChainID, bcm.NewBlockchain(testGenesisDoc), event.NewEmitter(logger),
+ return newExecutor(true, state, testChainID, bcm.NewBlockchain(nil, testGenesisDoc), event.NewEmitter(logger),
logger)
}
@@ -166,6 +172,7 @@ func newBaseGenDoc(globalPerm, accountPerm ptypes.AccountPermissions) genesis.Ge
func TestSendFails(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
+ defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
genDoc.Accounts[1].Permissions.Base.Set(permission.Send, true)
genDoc.Accounts[2].Permissions.Base.Set(permission.Call, true)
@@ -179,7 +186,7 @@ func TestSendFails(t *testing.T) {
// simple send tx should fail
tx := txs.NewSendTx()
- if err := tx.AddInput(batchCommitter.blockCache, users[0].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[0].PublicKey(), 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(users[1].Address(), 5)
@@ -192,7 +199,7 @@ func TestSendFails(t *testing.T) {
// simple send tx with call perm should fail
tx = txs.NewSendTx()
- if err := tx.AddInput(batchCommitter.blockCache, users[2].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[2].PublicKey(), 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(users[4].Address(), 5)
@@ -205,7 +212,7 @@ func TestSendFails(t *testing.T) {
// simple send tx with create perm should fail
tx = txs.NewSendTx()
- if err := tx.AddInput(batchCommitter.blockCache, users[3].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[3].PublicKey(), 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(users[4].Address(), 5)
@@ -217,11 +224,11 @@ func TestSendFails(t *testing.T) {
}
// simple send tx to unknown account without create_account perm should fail
- acc := getAccount(batchCommitter.blockCache, users[3].Address())
+ acc := getAccount(batchCommitter.stateCache, users[3].Address())
acc.MutablePermissions().Base.Set(permission.Send, true)
- batchCommitter.blockCache.UpdateAccount(acc)
+ batchCommitter.stateCache.UpdateAccount(acc)
tx = txs.NewSendTx()
- if err := tx.AddInput(batchCommitter.blockCache, users[3].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[3].PublicKey(), 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(users[6].Address(), 5)
@@ -235,6 +242,7 @@ func TestSendFails(t *testing.T) {
func TestName(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
+ defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
genDoc.Accounts[0].Permissions.Base.Set(permission.Send, true)
genDoc.Accounts[1].Permissions.Base.Set(permission.Name, true)
@@ -270,6 +278,7 @@ func TestName(t *testing.T) {
func TestCallFails(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
+ defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
genDoc.Accounts[1].Permissions.Base.Set(permission.Send, true)
genDoc.Accounts[2].Permissions.Base.Set(permission.Call, true)
@@ -283,7 +292,7 @@ func TestCallFails(t *testing.T) {
address4 := users[4].Address()
// simple call tx should fail
- tx, _ := txs.NewCallTx(batchCommitter.blockCache, users[0].PublicKey(), &address4, nil, 100, 100, 100)
+ tx, _ := txs.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &address4, nil, 100, 100, 100)
tx.Sign(testChainID, users[0])
if err := batchCommitter.Execute(tx); err == nil {
t.Fatal("Expected error")
@@ -292,7 +301,7 @@ func TestCallFails(t *testing.T) {
}
// simple call tx with send permission should fail
- tx, _ = txs.NewCallTx(batchCommitter.blockCache, users[1].PublicKey(), &address4, nil, 100, 100, 100)
+ tx, _ = txs.NewCallTx(batchCommitter.stateCache, users[1].PublicKey(), &address4, nil, 100, 100, 100)
tx.Sign(testChainID, users[1])
if err := batchCommitter.Execute(tx); err == nil {
t.Fatal("Expected error")
@@ -301,7 +310,7 @@ func TestCallFails(t *testing.T) {
}
// simple call tx with create permission should fail
- tx, _ = txs.NewCallTx(batchCommitter.blockCache, users[3].PublicKey(), &address4, nil, 100, 100, 100)
+ tx, _ = txs.NewCallTx(batchCommitter.stateCache, users[3].PublicKey(), &address4, nil, 100, 100, 100)
tx.Sign(testChainID, users[3])
if err := batchCommitter.Execute(tx); err == nil {
t.Fatal("Expected error")
@@ -313,7 +322,7 @@ func TestCallFails(t *testing.T) {
// create txs
// simple call create tx should fail
- tx, _ = txs.NewCallTx(batchCommitter.blockCache, users[0].PublicKey(), nil, nil, 100, 100, 100)
+ tx, _ = txs.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), nil, nil, 100, 100, 100)
tx.Sign(testChainID, users[0])
if err := batchCommitter.Execute(tx); err == nil {
t.Fatal("Expected error")
@@ -322,7 +331,7 @@ func TestCallFails(t *testing.T) {
}
// simple call create tx with send perm should fail
- tx, _ = txs.NewCallTx(batchCommitter.blockCache, users[1].PublicKey(), nil, nil, 100, 100, 100)
+ tx, _ = txs.NewCallTx(batchCommitter.stateCache, users[1].PublicKey(), nil, nil, 100, 100, 100)
tx.Sign(testChainID, users[1])
if err := batchCommitter.Execute(tx); err == nil {
t.Fatal("Expected error")
@@ -331,7 +340,7 @@ func TestCallFails(t *testing.T) {
}
// simple call create tx with call perm should fail
- tx, _ = txs.NewCallTx(batchCommitter.blockCache, users[2].PublicKey(), nil, nil, 100, 100, 100)
+ tx, _ = txs.NewCallTx(batchCommitter.stateCache, users[2].PublicKey(), nil, nil, 100, 100, 100)
tx.Sign(testChainID, users[2])
if err := batchCommitter.Execute(tx); err == nil {
t.Fatal("Expected error")
@@ -342,6 +351,7 @@ func TestCallFails(t *testing.T) {
func TestSendPermission(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
+ defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
genDoc.Accounts[0].Permissions.Base.Set(permission.Send, true) // give the 0 account permission
st, err := MakeGenesisState(stateDB, &genDoc)
@@ -350,7 +360,7 @@ func TestSendPermission(t *testing.T) {
// A single input, having the permission, should succeed
tx := txs.NewSendTx()
- if err := tx.AddInput(batchCommitter.blockCache, users[0].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[0].PublicKey(), 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(users[1].Address(), 5)
@@ -361,10 +371,10 @@ func TestSendPermission(t *testing.T) {
// Two inputs, one with permission, one without, should fail
tx = txs.NewSendTx()
- if err := tx.AddInput(batchCommitter.blockCache, users[0].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[0].PublicKey(), 5); err != nil {
t.Fatal(err)
}
- if err := tx.AddInput(batchCommitter.blockCache, users[1].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[1].PublicKey(), 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(users[2].Address(), 10)
@@ -379,6 +389,7 @@ func TestSendPermission(t *testing.T) {
func TestCallPermission(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
+ defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
genDoc.Accounts[0].Permissions.Base.Set(permission.Call, true) // give the 0 account permission
st, err := MakeGenesisState(stateDB, &genDoc)
@@ -402,7 +413,7 @@ func TestCallPermission(t *testing.T) {
st.UpdateAccount(simpleAcc)
// A single input, having the permission, should succeed
- tx, _ := txs.NewCallTx(batchCommitter.blockCache, users[0].PublicKey(), &simpleContractAddr, nil, 100, 100, 100)
+ tx, _ := txs.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &simpleContractAddr, nil, 100, 100, 100)
tx.Sign(testChainID, users[0])
if err := batchCommitter.Execute(tx); err != nil {
t.Fatal("Transaction failed", err)
@@ -423,10 +434,10 @@ func TestCallPermission(t *testing.T) {
StorageRoot: Zero256.Bytes(),
Permissions: permission.ZeroAccountPermissions,
}.MutableAccount()
- batchCommitter.blockCache.UpdateAccount(caller1Acc)
+ batchCommitter.stateCache.UpdateAccount(caller1Acc)
// A single input, having the permission, but the contract doesn't have permission
- tx, _ = txs.NewCallTx(batchCommitter.blockCache, users[0].PublicKey(), &caller1ContractAddr, nil, 100, 10000, 100)
+ tx, _ = txs.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &caller1ContractAddr, nil, 100, 10000, 100)
tx.Sign(testChainID, users[0])
// we need to subscribe to the Call event to detect the exception
@@ -441,8 +452,8 @@ func TestCallPermission(t *testing.T) {
// A single input, having the permission, and the contract has permission
caller1Acc.MutablePermissions().Base.Set(permission.Call, true)
- batchCommitter.blockCache.UpdateAccount(caller1Acc)
- tx, _ = txs.NewCallTx(batchCommitter.blockCache, users[0].PublicKey(), &caller1ContractAddr, nil, 100, 10000, 100)
+ batchCommitter.stateCache.UpdateAccount(caller1Acc)
+ tx, _ = txs.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &caller1ContractAddr, nil, 100, 10000, 100)
tx.Sign(testChainID, users[0])
// we need to subscribe to the Call event to detect the exception
@@ -469,10 +480,10 @@ func TestCallPermission(t *testing.T) {
}.MutableAccount()
caller1Acc.MutablePermissions().Base.Set(permission.Call, false)
caller2Acc.MutablePermissions().Base.Set(permission.Call, true)
- batchCommitter.blockCache.UpdateAccount(caller1Acc)
- batchCommitter.blockCache.UpdateAccount(caller2Acc)
+ batchCommitter.stateCache.UpdateAccount(caller1Acc)
+ batchCommitter.stateCache.UpdateAccount(caller2Acc)
- tx, _ = txs.NewCallTx(batchCommitter.blockCache, users[0].PublicKey(), &caller2ContractAddr, nil, 100, 10000, 100)
+ tx, _ = txs.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &caller2ContractAddr, nil, 100, 10000, 100)
tx.Sign(testChainID, users[0])
// we need to subscribe to the Call event to detect the exception
@@ -488,9 +499,9 @@ func TestCallPermission(t *testing.T) {
fmt.Println("\n##### CALL TO CONTRACT CALLING SIMPLE CONTRACT (PASS)")
caller1Acc.MutablePermissions().Base.Set(permission.Call, true)
- batchCommitter.blockCache.UpdateAccount(caller1Acc)
+ batchCommitter.stateCache.UpdateAccount(caller1Acc)
- tx, _ = txs.NewCallTx(batchCommitter.blockCache, users[0].PublicKey(), &caller2ContractAddr, nil, 100, 10000, 100)
+ tx, _ = txs.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &caller2ContractAddr, nil, 100, 10000, 100)
tx.Sign(testChainID, users[0])
// we need to subscribe to the Call event to detect the exception
@@ -502,6 +513,7 @@ func TestCallPermission(t *testing.T) {
func TestCreatePermission(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
+ defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
genDoc.Accounts[0].Permissions.Base.Set(permission.CreateContract, true) // give the 0 account permission
genDoc.Accounts[0].Permissions.Base.Set(permission.Call, true) // give the 0 account permission
@@ -517,14 +529,14 @@ func TestCreatePermission(t *testing.T) {
createCode := wrapContractForCreate(contractCode)
// A single input, having the permission, should succeed
- tx, _ := txs.NewCallTx(batchCommitter.blockCache, users[0].PublicKey(), nil, createCode, 100, 100, 100)
+ tx, _ := txs.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), nil, createCode, 100, 100, 100)
tx.Sign(testChainID, users[0])
if err := batchCommitter.Execute(tx); err != nil {
t.Fatal("Transaction failed", err)
}
// ensure the contract is there
contractAddr := acm.NewContractAddress(tx.Input.Address, tx.Input.Sequence)
- contractAcc := getAccount(batchCommitter.blockCache, contractAddr)
+ contractAcc := getAccount(batchCommitter.stateCache, contractAddr)
if contractAcc == nil {
t.Fatalf("failed to create contract %s", contractAddr)
}
@@ -542,14 +554,14 @@ func TestCreatePermission(t *testing.T) {
createFactoryCode := wrapContractForCreate(factoryCode)
// A single input, having the permission, should succeed
- tx, _ = txs.NewCallTx(batchCommitter.blockCache, users[0].PublicKey(), nil, createFactoryCode, 100, 100, 100)
+ tx, _ = txs.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), nil, createFactoryCode, 100, 100, 100)
tx.Sign(testChainID, users[0])
if err := batchCommitter.Execute(tx); err != nil {
t.Fatal("Transaction failed", err)
}
// ensure the contract is there
contractAddr = acm.NewContractAddress(tx.Input.Address, tx.Input.Sequence)
- contractAcc = getAccount(batchCommitter.blockCache, contractAddr)
+ contractAcc = getAccount(batchCommitter.stateCache, contractAddr)
if contractAcc == nil {
t.Fatalf("failed to create contract %s", contractAddr)
}
@@ -562,7 +574,7 @@ func TestCreatePermission(t *testing.T) {
fmt.Println("\n###### CALL THE FACTORY (FAIL)")
// A single input, having the permission, should succeed
- tx, _ = txs.NewCallTx(batchCommitter.blockCache, users[0].PublicKey(), &contractAddr, createCode, 100, 100, 100)
+ tx, _ = txs.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &contractAddr, createCode, 100, 100, 100)
tx.Sign(testChainID, users[0])
// we need to subscribe to the Call event to detect the exception
_, exception := execTxWaitEvent(t, batchCommitter, tx, evm_events.EventStringAccountCall(contractAddr)) //
@@ -575,10 +587,10 @@ func TestCreatePermission(t *testing.T) {
fmt.Println("\n###### CALL THE FACTORY (PASS)")
contractAcc.MutablePermissions().Base.Set(permission.CreateContract, true)
- batchCommitter.blockCache.UpdateAccount(contractAcc)
+ batchCommitter.stateCache.UpdateAccount(contractAcc)
// A single input, having the permission, should succeed
- tx, _ = txs.NewCallTx(batchCommitter.blockCache, users[0].PublicKey(), &contractAddr, createCode, 100, 100, 100)
+ tx, _ = txs.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &contractAddr, createCode, 100, 100, 100)
tx.Sign(testChainID, users[0])
// we need to subscribe to the Call event to detect the exception
_, exception = execTxWaitEvent(t, batchCommitter, tx, evm_events.EventStringAccountCall(contractAddr)) //
@@ -601,149 +613,25 @@ func TestCreatePermission(t *testing.T) {
}.MutableAccount()
contractAcc.MutablePermissions().Base.Set(permission.Call, true)
contractAcc.MutablePermissions().Base.Set(permission.CreateContract, true)
- batchCommitter.blockCache.UpdateAccount(contractAcc)
+ batchCommitter.stateCache.UpdateAccount(contractAcc)
// this should call the 0 address but not create ...
- tx, _ = txs.NewCallTx(batchCommitter.blockCache, users[0].PublicKey(), &contractAddr, createCode, 100, 10000, 100)
+ tx, _ = txs.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &contractAddr, createCode, 100, 10000, 100)
tx.Sign(testChainID, users[0])
// we need to subscribe to the Call event to detect the exception
_, exception = execTxWaitEvent(t, batchCommitter, tx, evm_events.EventStringAccountCall(acm.Address{})) //
if exception != "" {
t.Fatal("unexpected exception", exception)
}
- zeroAcc := getAccount(batchCommitter.blockCache, acm.Address{})
+ zeroAcc := getAccount(batchCommitter.stateCache, acm.Address{})
if len(zeroAcc.Code()) != 0 {
t.Fatal("the zero account was given code from a CALL!")
}
}
-/* TODO
-func TestBondPermission(t *testing.T) {
- stateDB := dbm.NewDB("state",dbBackend,dbDir)
- genDoc := newBaseGenDoc(PermsAllFalse, PermsAllFalse)
- st, err := MakeGenesisState(stateDB, &genDoc)
- batchCommitter := makeExecutor(st)
- var bondAcc *acm.Account
-
- //------------------------------
- // one bonder without permission should fail
- tx, _ := txs.NewBondTx(users[1].PublicKey())
- if err := tx.AddInput(batchCommitter.blockCache, users[1].PublicKey(), 5); err != nil {
- t.Fatal(err)
- }
- tx.AddOutput(users[1].Address(), 5)
- tx.SignInput(testChainID, 0, users[1])
- tx.SignBond(testChainID, users[1])
- if err := ExecTx(batchCommitter.blockCache, tx, true, nil); err == nil {
- t.Fatal("Expected error")
- } else {
- fmt.Println(err)
- }
-
- //------------------------------
- // one bonder with permission should pass
- bondAcc = batchCommitter.blockCache.GetAccount(users[1].Address())
- bondAcc.Permissions.Base.Set(permission.Bond, true)
- batchCommitter.blockCache.UpdateAccount(bondAcc)
- if err := ExecTx(batchCommitter.blockCache, tx, true, nil); err != nil {
- t.Fatal("Unexpected error", err)
- }
-
- // reset state (we can only bond with an account once ..)
- genDoc = newBaseGenDoc(PermsAllFalse, PermsAllFalse)
- st = MakeGenesisState(stateDB, &genDoc)
- batchCommitter.blockCache = NewBlockCache(st)
- bondAcc = batchCommitter.blockCache.GetAccount(users[1].Address())
- bondAcc.Permissions.Base.Set(permission.Bond, true)
- batchCommitter.blockCache.UpdateAccount(bondAcc)
- //------------------------------
- // one bonder with permission and an input without send should fail
- tx, _ = txs.NewBondTx(users[1].PublicKey())
- if err := tx.AddInput(batchCommitter.blockCache, users[2].PublicKey(), 5); err != nil {
- t.Fatal(err)
- }
- tx.AddOutput(users[1].Address(), 5)
- tx.SignInput(testChainID, 0, users[2])
- tx.SignBond(testChainID, users[1])
- if err := ExecTx(batchCommitter.blockCache, tx, true, nil); err == nil {
- t.Fatal("Expected error")
- } else {
- fmt.Println(err)
- }
-
- // reset state (we can only bond with an account once ..)
- genDoc = newBaseGenDoc(PermsAllFalse, PermsAllFalse)
- st = MakeGenesisState(stateDB, &genDoc)
- batchCommitter.blockCache = NewBlockCache(st)
- bondAcc = batchCommitter.blockCache.GetAccount(users[1].Address())
- bondAcc.Permissions.Base.Set(permission.Bond, true)
- batchCommitter.blockCache.UpdateAccount(bondAcc)
- //------------------------------
- // one bonder with permission and an input with send should pass
- sendAcc := batchCommitter.blockCache.GetAccount(users[2].Address())
- sendAcc.Permissions.Base.Set(permission.Send, true)
- batchCommitter.blockCache.UpdateAccount(sendAcc)
- tx, _ = txs.NewBondTx(users[1].PublicKey())
- if err := tx.AddInput(batchCommitter.blockCache, users[2].PublicKey(), 5); err != nil {
- t.Fatal(err)
- }
- tx.AddOutput(users[1].Address(), 5)
- tx.SignInput(testChainID, 0, users[2])
- tx.SignBond(testChainID, users[1])
- if err := ExecTx(batchCommitter.blockCache, tx, true, nil); err != nil {
- t.Fatal("Unexpected error", err)
- }
-
- // reset state (we can only bond with an account once ..)
- genDoc = newBaseGenDoc(PermsAllFalse, PermsAllFalse)
- st = MakeGenesisState(stateDB, &genDoc)
- batchCommitter.blockCache = NewBlockCache(st)
- bondAcc = batchCommitter.blockCache.GetAccount(users[1].Address())
- bondAcc.Permissions.Base.Set(permission.Bond, true)
- batchCommitter.blockCache.UpdateAccount(bondAcc)
- //------------------------------
- // one bonder with permission and an input with bond should pass
- sendAcc.Permissions.Base.Set(permission.Bond, true)
- batchCommitter.blockCache.UpdateAccount(sendAcc)
- tx, _ = txs.NewBondTx(users[1].PublicKey())
- if err := tx.AddInput(batchCommitter.blockCache, users[2].PublicKey(), 5); err != nil {
- t.Fatal(err)
- }
- tx.AddOutput(users[1].Address(), 5)
- tx.SignInput(testChainID, 0, users[2])
- tx.SignBond(testChainID, users[1])
- if err := ExecTx(batchCommitter.blockCache, tx, true, nil); err != nil {
- t.Fatal("Unexpected error", err)
- }
-
- // reset state (we can only bond with an account once ..)
- genDoc = newBaseGenDoc(PermsAllFalse, PermsAllFalse)
- st = MakeGenesisState(stateDB, &genDoc)
- batchCommitter.blockCache = NewBlockCache(st)
- bondAcc = batchCommitter.blockCache.GetAccount(users[1].Address())
- bondAcc.Permissions.Base.Set(permission.Bond, true)
- batchCommitter.blockCache.UpdateAccount(bondAcc)
- //------------------------------
- // one bonder with permission and an input from that bonder and an input without send or bond should fail
- tx, _ = txs.NewBondTx(users[1].PublicKey())
- if err := tx.AddInput(batchCommitter.blockCache, users[1].PublicKey(), 5); err != nil {
- t.Fatal(err)
- }
- if err := tx.AddInput(batchCommitter.blockCache, users[2].PublicKey(), 5); err != nil {
- t.Fatal(err)
- }
- tx.AddOutput(users[1].Address(), 5)
- tx.SignInput(testChainID, 0, users[1])
- tx.SignInput(testChainID, 1, users[2])
- tx.SignBond(testChainID, users[1])
- if err := ExecTx(batchCommitter.blockCache, tx, true, nil); err == nil {
- t.Fatal("Expected error")
- }
-}
-*/
-
func TestCreateAccountPermission(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
+ defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
genDoc.Accounts[0].Permissions.Base.Set(permission.Send, true) // give the 0 account permission
genDoc.Accounts[1].Permissions.Base.Set(permission.Send, true) // give the 0 account permission
@@ -757,7 +645,7 @@ func TestCreateAccountPermission(t *testing.T) {
// A single input, having the permission, should succeed
tx := txs.NewSendTx()
- if err := tx.AddInput(batchCommitter.blockCache, users[0].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[0].PublicKey(), 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(users[6].Address(), 5)
@@ -768,10 +656,10 @@ func TestCreateAccountPermission(t *testing.T) {
// Two inputs, both with send, one with create, one without, should fail
tx = txs.NewSendTx()
- if err := tx.AddInput(batchCommitter.blockCache, users[0].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[0].PublicKey(), 5); err != nil {
t.Fatal(err)
}
- if err := tx.AddInput(batchCommitter.blockCache, users[1].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[1].PublicKey(), 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(users[7].Address(), 10)
@@ -785,10 +673,10 @@ func TestCreateAccountPermission(t *testing.T) {
// Two inputs, both with send, one with create, one without, two ouputs (one known, one unknown) should fail
tx = txs.NewSendTx()
- if err := tx.AddInput(batchCommitter.blockCache, users[0].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[0].PublicKey(), 5); err != nil {
t.Fatal(err)
}
- if err := tx.AddInput(batchCommitter.blockCache, users[1].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[1].PublicKey(), 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(users[7].Address(), 4)
@@ -802,14 +690,14 @@ func TestCreateAccountPermission(t *testing.T) {
}
// Two inputs, both with send, both with create, should pass
- acc := getAccount(batchCommitter.blockCache, users[1].Address())
+ acc := getAccount(batchCommitter.stateCache, users[1].Address())
acc.MutablePermissions().Base.Set(permission.CreateAccount, true)
- batchCommitter.blockCache.UpdateAccount(acc)
+ batchCommitter.stateCache.UpdateAccount(acc)
tx = txs.NewSendTx()
- if err := tx.AddInput(batchCommitter.blockCache, users[0].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[0].PublicKey(), 5); err != nil {
t.Fatal(err)
}
- if err := tx.AddInput(batchCommitter.blockCache, users[1].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[1].PublicKey(), 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(users[7].Address(), 10)
@@ -821,10 +709,10 @@ func TestCreateAccountPermission(t *testing.T) {
// Two inputs, both with send, both with create, two outputs (one known, one unknown) should pass
tx = txs.NewSendTx()
- if err := tx.AddInput(batchCommitter.blockCache, users[0].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[0].PublicKey(), 5); err != nil {
t.Fatal(err)
}
- if err := tx.AddInput(batchCommitter.blockCache, users[1].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(batchCommitter.stateCache, users[1].PublicKey(), 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(users[7].Address(), 7)
@@ -838,9 +726,9 @@ func TestCreateAccountPermission(t *testing.T) {
//----------------------------------------------------------
// CALL to unknown account
- acc = getAccount(batchCommitter.blockCache, users[0].Address())
+ acc = getAccount(batchCommitter.stateCache, users[0].Address())
acc.MutablePermissions().Base.Set(permission.Call, true)
- batchCommitter.blockCache.UpdateAccount(acc)
+ batchCommitter.stateCache.UpdateAccount(acc)
// call to contract that calls unknown account - without create_account perm
// create contract that calls the simple contract
@@ -854,10 +742,10 @@ func TestCreateAccountPermission(t *testing.T) {
StorageRoot: Zero256.Bytes(),
Permissions: permission.ZeroAccountPermissions,
}.MutableAccount()
- batchCommitter.blockCache.UpdateAccount(caller1Acc)
+ batchCommitter.stateCache.UpdateAccount(caller1Acc)
// A single input, having the permission, but the contract doesn't have permission
- txCall, _ := txs.NewCallTx(batchCommitter.blockCache, users[0].PublicKey(), &caller1ContractAddr, nil, 100, 10000, 100)
+ txCall, _ := txs.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &caller1ContractAddr, nil, 100, 10000, 100)
txCall.Sign(testChainID, users[0])
// we need to subscribe to the Call event to detect the exception
@@ -870,9 +758,9 @@ func TestCreateAccountPermission(t *testing.T) {
// NOTE: for a users to be able to CreateAccount, it must be able to send!
caller1Acc.MutablePermissions().Base.Set(permission.CreateAccount, true)
caller1Acc.MutablePermissions().Base.Set(permission.Call, true)
- batchCommitter.blockCache.UpdateAccount(caller1Acc)
+ batchCommitter.stateCache.UpdateAccount(caller1Acc)
// A single input, having the permission, but the contract doesn't have permission
- txCall, _ = txs.NewCallTx(batchCommitter.blockCache, users[0].PublicKey(), &caller1ContractAddr, nil, 100, 10000, 100)
+ txCall, _ = txs.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &caller1ContractAddr, nil, 100, 10000, 100)
txCall.Sign(testChainID, users[0])
// we need to subscribe to the Call event to detect the exception
@@ -892,6 +780,7 @@ func init() {
func TestSNativeCALL(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
+ defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
genDoc.Accounts[0].Permissions.Base.Set(permission.Call, true) // give the 0 account permission
genDoc.Accounts[3].Permissions.Base.Set(permission.Bond, true) // some arbitrary permission to play with
@@ -916,7 +805,7 @@ func TestSNativeCALL(t *testing.T) {
doug.MutablePermissions().Base.Set(permission.Call, true)
//doug.Permissions.Base.Set(permission.HasBase, true)
- batchCommitter.blockCache.UpdateAccount(doug)
+ batchCommitter.stateCache.UpdateAccount(doug)
fmt.Println("\n#### HasBase")
// HasBase
@@ -1028,6 +917,7 @@ func TestSNativeCALL(t *testing.T) {
func TestSNativeTx(t *testing.T) {
stateDB := dbm.NewDB("state", dbBackend, dbDir)
+ defer stateDB.Close()
genDoc := newBaseGenDoc(permission.ZeroAccountPermissions, permission.ZeroAccountPermissions)
genDoc.Accounts[0].Permissions.Base.Set(permission.Call, true) // give the 0 account permission
genDoc.Accounts[3].Permissions.Base.Set(permission.Bond, true) // some arbitrary permission to play with
@@ -1045,13 +935,13 @@ func TestSNativeTx(t *testing.T) {
snativeArgs := snativePermTestInputTx("setBase", users[3], permission.Bond, false)
testSNativeTxExpectFail(t, batchCommitter, snativeArgs)
testSNativeTxExpectPass(t, batchCommitter, permission.SetBase, snativeArgs)
- acc := getAccount(batchCommitter.blockCache, users[3].Address())
+ acc := getAccount(batchCommitter.stateCache, users[3].Address())
if v, _ := acc.MutablePermissions().Base.Get(permission.Bond); v {
t.Fatal("expected permission to be set false")
}
snativeArgs = snativePermTestInputTx("setBase", users[3], permission.CreateContract, true)
testSNativeTxExpectPass(t, batchCommitter, permission.SetBase, snativeArgs)
- acc = getAccount(batchCommitter.blockCache, users[3].Address())
+ acc = getAccount(batchCommitter.stateCache, users[3].Address())
if v, _ := acc.MutablePermissions().Base.Get(permission.CreateContract); !v {
t.Fatal("expected permission to be set true")
}
@@ -1061,7 +951,7 @@ func TestSNativeTx(t *testing.T) {
snativeArgs = snativePermTestInputTx("unsetBase", users[3], permission.CreateContract, false)
testSNativeTxExpectFail(t, batchCommitter, snativeArgs)
testSNativeTxExpectPass(t, batchCommitter, permission.UnsetBase, snativeArgs)
- acc = getAccount(batchCommitter.blockCache, users[3].Address())
+ acc = getAccount(batchCommitter.stateCache, users[3].Address())
if v, _ := acc.MutablePermissions().Base.Get(permission.CreateContract); v {
t.Fatal("expected permission to be set false")
}
@@ -1071,7 +961,7 @@ func TestSNativeTx(t *testing.T) {
snativeArgs = snativePermTestInputTx("setGlobal", users[3], permission.CreateContract, true)
testSNativeTxExpectFail(t, batchCommitter, snativeArgs)
testSNativeTxExpectPass(t, batchCommitter, permission.SetGlobal, snativeArgs)
- acc = getAccount(batchCommitter.blockCache, permission.GlobalPermissionsAddress)
+ acc = getAccount(batchCommitter.stateCache, permission.GlobalPermissionsAddress)
if v, _ := acc.MutablePermissions().Base.Get(permission.CreateContract); !v {
t.Fatal("expected permission to be set true")
}
@@ -1081,7 +971,7 @@ func TestSNativeTx(t *testing.T) {
snativeArgs = snativeRoleTestInputTx("addRole", users[3], "chuck")
testSNativeTxExpectFail(t, batchCommitter, snativeArgs)
testSNativeTxExpectPass(t, batchCommitter, permission.AddRole, snativeArgs)
- acc = getAccount(batchCommitter.blockCache, users[3].Address())
+ acc = getAccount(batchCommitter.stateCache, users[3].Address())
if v := acc.Permissions().HasRole("chuck"); !v {
t.Fatal("expected role to be added")
}
@@ -1091,12 +981,755 @@ func TestSNativeTx(t *testing.T) {
snativeArgs = snativeRoleTestInputTx("removeRole", users[3], "chuck")
testSNativeTxExpectFail(t, batchCommitter, snativeArgs)
testSNativeTxExpectPass(t, batchCommitter, permission.RemoveRole, snativeArgs)
- acc = getAccount(batchCommitter.blockCache, users[3].Address())
+ acc = getAccount(batchCommitter.stateCache, users[3].Address())
if v := acc.Permissions().HasRole("chuck"); v {
t.Fatal("expected role to be removed")
}
}
+func TestTxSequence(t *testing.T) {
+ state, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
+ acc0 := getAccount(state, privAccounts[0].Address())
+ acc0PubKey := privAccounts[0].PublicKey()
+ acc1 := getAccount(state, privAccounts[1].Address())
+
+ // Test a variety of sequence numbers for the tx.
+ // The tx should only pass when i == 1.
+ for i := uint64(0); i < 3; i++ {
+ sequence := acc0.Sequence() + i
+ tx := txs.NewSendTx()
+ tx.AddInputWithSequence(acc0PubKey, 1, sequence)
+ tx.AddOutput(acc1.Address(), 1)
+ tx.Inputs[0].Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
+ stateCopy := state.Copy(dbm.NewMemDB())
+ err := execTxWithState(stateCopy, tx)
+ if i == 1 {
+ // Sequence is good.
+ if err != nil {
+ t.Errorf("Expected good sequence to pass: %v", err)
+ }
+ // Check acc.Sequence().
+ newAcc0 := getAccount(stateCopy, acc0.Address())
+ if newAcc0.Sequence() != sequence {
+ t.Errorf("Expected account sequence to change to %v, got %v",
+ sequence, newAcc0.Sequence())
+ }
+ } else {
+ // Sequence is bad.
+ if err == nil {
+ t.Errorf("Expected bad sequence to fail")
+ }
+ // Check acc.Sequence(). (shouldn't have changed)
+ newAcc0 := getAccount(stateCopy, acc0.Address())
+ if newAcc0.Sequence() != acc0.Sequence() {
+ t.Errorf("Expected account sequence to not change from %v, got %v",
+ acc0.Sequence(), newAcc0.Sequence())
+ }
+ }
+ }
+}
+
+func TestNameTxs(t *testing.T) {
+ state, err := MakeGenesisState(dbm.NewMemDB(), testGenesisDoc)
+ require.NoError(t, err)
+ state.Save()
+
+ txs.MinNameRegistrationPeriod = 5
+ blockchain := bcm.NewBlockchain(nil, testGenesisDoc)
+ startingBlock := blockchain.LastBlockHeight()
+
+ // try some bad names. these should all fail
+ names := []string{"", "\n", "123#$%", "\x00", string([]byte{20, 40, 60, 80}),
+ "baffledbythespectacleinallofthisyouseeehesaidwithouteyessurprised", "no spaces please"}
+ data := "something about all this just doesn't feel right."
+ fee := uint64(1000)
+ numDesiredBlocks := uint64(5)
+ for _, name := range names {
+ amt := fee + numDesiredBlocks*txs.NameByteCostMultiplier*txs.NameBlockCostMultiplier*
+ txs.NameBaseCost(name, data)
+ tx, _ := txs.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
+ tx.Sign(testChainID, testPrivAccounts[0])
+
+ if err := execTxWithState(state, tx); err == nil {
+ t.Fatalf("Expected invalid name error from %s", name)
+ }
+ }
+
+ // try some bad data. these should all fail
+ name := "hold_it_chum"
+ datas := []string{"cold&warm", "!@#$%^&*()", "<<<>>>>", "because why would you ever need a ~ or a & or even a % in a json file? make your case and we'll talk"}
+ for _, data := range datas {
+ amt := fee + numDesiredBlocks*txs.NameByteCostMultiplier*txs.NameBlockCostMultiplier*
+ txs.NameBaseCost(name, data)
+ tx, _ := txs.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
+ tx.Sign(testChainID, testPrivAccounts[0])
+
+ if err := execTxWithState(state, tx); err == nil {
+ t.Fatalf("Expected invalid data error from %s", data)
+ }
+ }
+
+ validateEntry := func(t *testing.T, entry *NameRegEntry, name, data string, addr acm.Address, expires uint64) {
+
+ if entry == nil {
+ t.Fatalf("Could not find name %s", name)
+ }
+ if entry.Owner != addr {
+ t.Fatalf("Wrong owner. Got %s expected %s", entry.Owner, addr)
+ }
+ if data != entry.Data {
+ t.Fatalf("Wrong data. Got %s expected %s", entry.Data, data)
+ }
+ if name != entry.Name {
+ t.Fatalf("Wrong name. Got %s expected %s", entry.Name, name)
+ }
+ if expires != entry.Expires {
+ t.Fatalf("Wrong expiry. Got %d, expected %d", entry.Expires, expires)
+ }
+ }
+
+ // try a good one, check data, owner, expiry
+ name = "@looking_good/karaoke_bar.broadband"
+ data = "on this side of neptune there are 1234567890 people: first is OMNIVORE+-3. Or is it. Ok this is pretty restrictive. No exclamations :(. Faces tho :')"
+ amt := fee + numDesiredBlocks*txs.NameByteCostMultiplier*txs.NameBlockCostMultiplier*txs.NameBaseCost(name, data)
+ tx, _ := txs.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
+ tx.Sign(testChainID, testPrivAccounts[0])
+ if err := execTxWithState(state, tx); err != nil {
+ t.Fatal(err)
+ }
+ entry, err := state.GetNameRegEntry(name)
+ require.NoError(t, err)
+ validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), startingBlock+numDesiredBlocks)
+
+ // fail to update it as non-owner, in same block
+ tx, _ = txs.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
+ tx.Sign(testChainID, testPrivAccounts[1])
+ if err := execTxWithState(state, tx); err == nil {
+ t.Fatal("Expected error")
+ }
+
+ // update it as owner, just to increase expiry, in same block
+ // NOTE: we have to resend the data or it will clear it (is this what we want?)
+ tx, _ = txs.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
+ tx.Sign(testChainID, testPrivAccounts[0])
+ if err := execTxWithStateNewBlock(state, blockchain, tx); err != nil {
+ t.Fatal(err)
+ }
+ entry, err = state.GetNameRegEntry(name)
+ require.NoError(t, err)
+ validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), startingBlock+numDesiredBlocks*2)
+
+ // update it as owner, just to increase expiry, in next block
+ tx, _ = txs.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
+ tx.Sign(testChainID, testPrivAccounts[0])
+ if err := execTxWithStateNewBlock(state, blockchain, tx); err != nil {
+ t.Fatal(err)
+ }
+ entry, err = state.GetNameRegEntry(name)
+ require.NoError(t, err)
+ validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), startingBlock+numDesiredBlocks*3)
+
+ // fail to update it as non-owner
+ // Fast forward
+ for blockchain.Tip().LastBlockHeight() < entry.Expires-1 {
+ commitNewBlock(state, blockchain)
+ }
+ tx, _ = txs.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
+ tx.Sign(testChainID, testPrivAccounts[1])
+ if err := execTxWithStateAndBlockchain(state, blockchain, tx); err == nil {
+ t.Fatal("Expected error")
+ }
+ commitNewBlock(state, blockchain)
+
+ // once expires, non-owner succeeds
+ tx, _ = txs.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
+ tx.Sign(testChainID, testPrivAccounts[1])
+ if err := execTxWithStateAndBlockchain(state, blockchain, tx); err != nil {
+ t.Fatal(err)
+ }
+ entry, err = state.GetNameRegEntry(name)
+ require.NoError(t, err)
+ validateEntry(t, entry, name, data, testPrivAccounts[1].Address(), blockchain.LastBlockHeight()+numDesiredBlocks)
+
+ // update it as new owner, with new data (longer), but keep the expiry!
+ data = "In the beginning there was no thing, not even the beginning. It hadn't been here, no there, nor for that matter anywhere, not especially because it had not to even exist, let alone to not. Nothing especially odd about that."
+ oldCredit := amt - fee
+ numDesiredBlocks = 10
+ amt = fee + numDesiredBlocks*txs.NameByteCostMultiplier*txs.NameBlockCostMultiplier*txs.NameBaseCost(name, data) - oldCredit
+ tx, _ = txs.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
+ tx.Sign(testChainID, testPrivAccounts[1])
+ if err := execTxWithStateAndBlockchain(state, blockchain, tx); err != nil {
+ t.Fatal(err)
+ }
+ entry, err = state.GetNameRegEntry(name)
+ require.NoError(t, err)
+ validateEntry(t, entry, name, data, testPrivAccounts[1].Address(), blockchain.LastBlockHeight()+numDesiredBlocks)
+
+ // test removal
+ amt = fee
+ data = ""
+ tx, _ = txs.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
+ tx.Sign(testChainID, testPrivAccounts[1])
+ if err := execTxWithStateNewBlock(state, blockchain, tx); err != nil {
+ t.Fatal(err)
+ }
+ entry, err = state.GetNameRegEntry(name)
+ require.NoError(t, err)
+ if entry != nil {
+ t.Fatal("Expected removed entry to be nil")
+ }
+
+ // create entry by key0,
+ // test removal by key1 after expiry
+ name = "looking_good/karaoke_bar"
+ data = "some data"
+ amt = fee + numDesiredBlocks*txs.NameByteCostMultiplier*txs.NameBlockCostMultiplier*txs.NameBaseCost(name, data)
+ tx, _ = txs.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
+ tx.Sign(testChainID, testPrivAccounts[0])
+ if err := execTxWithStateAndBlockchain(state, blockchain, tx); err != nil {
+ t.Fatal(err)
+ }
+ entry, err = state.GetNameRegEntry(name)
+ require.NoError(t, err)
+ validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), blockchain.LastBlockHeight()+numDesiredBlocks)
+ // Fast forward
+ for blockchain.Tip().LastBlockHeight() < entry.Expires {
+ commitNewBlock(state, blockchain)
+ }
+
+ amt = fee
+ data = ""
+ tx, _ = txs.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
+ tx.Sign(testChainID, testPrivAccounts[1])
+ if err := execTxWithStateNewBlock(state, blockchain, tx); err != nil {
+ t.Fatal(err)
+ }
+ entry, err = state.GetNameRegEntry(name)
+ require.NoError(t, err)
+ if entry != nil {
+ t.Fatal("Expected removed entry to be nil")
+ }
+}
+
+// Test creating a contract from futher down the call stack
+/*
+contract Factory {
+ address a;
+ function create() returns (address){
+ a = new PreFactory();
+ return a;
+ }
+}
+
+contract PreFactory{
+ address a;
+ function create(Factory c) returns (address) {
+ a = c.create();
+ return a;
+ }
+}
+*/
+
+// run-time byte code for each of the above
+var preFactoryCode, _ = hex.DecodeString("60606040526000357C0100000000000000000000000000000000000000000000000000000000900480639ED933181461003957610037565B005B61004F600480803590602001909190505061007B565B604051808273FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF16815260200191505060405180910390F35B60008173FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF1663EFC81A8C604051817C01000000000000000000000000000000000000000000000000000000000281526004018090506020604051808303816000876161DA5A03F1156100025750505060405180519060200150600060006101000A81548173FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF02191690830217905550600060009054906101000A900473FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF16905061013C565B91905056")
+var factoryCode, _ = hex.DecodeString("60606040526000357C010000000000000000000000000000000000000000000000000000000090048063EFC81A8C146037576035565B005B60426004805050606E565B604051808273FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF16815260200191505060405180910390F35B6000604051610153806100E0833901809050604051809103906000F0600060006101000A81548173FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF02191690830217905550600060009054906101000A900473FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF16905060DD565B90566060604052610141806100126000396000F360606040526000357C0100000000000000000000000000000000000000000000000000000000900480639ED933181461003957610037565B005B61004F600480803590602001909190505061007B565B604051808273FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF16815260200191505060405180910390F35B60008173FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF1663EFC81A8C604051817C01000000000000000000000000000000000000000000000000000000000281526004018090506020604051808303816000876161DA5A03F1156100025750505060405180519060200150600060006101000A81548173FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF02191690830217905550600060009054906101000A900473FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF16905061013C565B91905056")
+var createData, _ = hex.DecodeString("9ed93318")
+
+func TestCreates(t *testing.T) {
+ //evm.SetDebug(true)
+ state, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
+
+ //val0 := state.GetValidatorInfo(privValidators[0].Address())
+ acc0 := getAccount(state, privAccounts[0].Address())
+ acc0PubKey := privAccounts[0].PublicKey()
+ acc1 := getAccount(state, privAccounts[1].Address())
+ acc2 := getAccount(state, privAccounts[2].Address())
+
+ newAcc1 := getAccount(state, acc1.Address())
+ newAcc1.SetCode(preFactoryCode)
+ newAcc2 := getAccount(state, acc2.Address())
+ newAcc2.SetCode(factoryCode)
+
+ state.UpdateAccount(newAcc1)
+ state.UpdateAccount(newAcc2)
+
+ createData = append(createData, acc2.Address().Word256().Bytes()...)
+
+ // call the pre-factory, triggering the factory to run a create
+ tx := &txs.CallTx{
+ Input: &txs.TxInput{
+ Address: acc0.Address(),
+ Amount: 1,
+ Sequence: acc0.Sequence() + 1,
+ PublicKey: acc0PubKey,
+ },
+ Address: addressPtr(acc1),
+ GasLimit: 10000,
+ Data: createData,
+ }
+
+ tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
+ err := execTxWithState(state, tx)
+ if err != nil {
+ t.Errorf("Got error in executing call transaction, %v", err)
+ }
+
+ acc1 = getAccount(state, acc1.Address())
+ firstCreatedAddress, err := state.GetStorage(acc1.Address(), LeftPadWord256(nil))
+ require.NoError(t, err)
+
+ acc0 = getAccount(state, acc0.Address())
+ // call the pre-factory, triggering the factory to run a create
+ tx = &txs.CallTx{
+ Input: &txs.TxInput{
+ Address: acc0.Address(),
+ Amount: 1,
+ Sequence: acc0.Sequence() + 1,
+ PublicKey: acc0PubKey,
+ },
+ Address: addressPtr(acc1),
+ GasLimit: 100000,
+ Data: createData,
+ }
+
+ tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
+ err = execTxWithState(state, tx)
+ if err != nil {
+ t.Errorf("Got error in executing call transaction, %v", err)
+ }
+
+ acc1 = getAccount(state, acc1.Address())
+ secondCreatedAddress, err := state.GetStorage(acc1.Address(), LeftPadWord256(nil))
+ require.NoError(t, err)
+
+ if firstCreatedAddress == secondCreatedAddress {
+ t.Errorf("Multiple contracts created with the same address!")
+ }
+}
+
+/*
+contract Caller {
+ function send(address x){
+ x.send(msg.value);
+ }
+}
+*/
+var callerCode, _ = hex.DecodeString("60606040526000357c0100000000000000000000000000000000000000000000000000000000900480633e58c58c146037576035565b005b604b6004808035906020019091905050604d565b005b8073ffffffffffffffffffffffffffffffffffffffff16600034604051809050600060405180830381858888f19350505050505b5056")
+var sendData, _ = hex.DecodeString("3e58c58c")
+
+func TestContractSend(t *testing.T) {
+ state, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
+
+ //val0 := state.GetValidatorInfo(privValidators[0].Address())
+ acc0 := getAccount(state, privAccounts[0].Address())
+ acc0PubKey := privAccounts[0].PublicKey()
+ acc1 := getAccount(state, privAccounts[1].Address())
+ acc2 := getAccount(state, privAccounts[2].Address())
+
+ newAcc1 := getAccount(state, acc1.Address())
+ newAcc1.SetCode(callerCode)
+ state.UpdateAccount(newAcc1)
+
+ sendData = append(sendData, acc2.Address().Word256().Bytes()...)
+ sendAmt := uint64(10)
+ acc2Balance := acc2.Balance()
+
+ // call the contract, triggering the send
+ tx := &txs.CallTx{
+ Input: &txs.TxInput{
+ Address: acc0.Address(),
+ Amount: sendAmt,
+ Sequence: acc0.Sequence() + 1,
+ PublicKey: acc0PubKey,
+ },
+ Address: addressPtr(acc1),
+ GasLimit: 1000,
+ Data: sendData,
+ }
+
+ tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
+ err := execTxWithState(state, tx)
+ if err != nil {
+ t.Errorf("Got error in executing call transaction, %v", err)
+ }
+
+ acc2 = getAccount(state, acc2.Address())
+ if acc2.Balance() != sendAmt+acc2Balance {
+ t.Errorf("Value transfer from contract failed! Got %d, expected %d", acc2.Balance(), sendAmt+acc2Balance)
+ }
+}
+
+func TestMerklePanic(t *testing.T) {
+ state, privAccounts := makeGenesisState(3, true, 1000, 1, true,
+ 1000)
+
+ //val0 := state.GetValidatorInfo(privValidators[0].Address())
+ acc0 := getAccount(state, privAccounts[0].Address())
+ acc0PubKey := privAccounts[0].PublicKey()
+ acc1 := getAccount(state, privAccounts[1].Address())
+
+ state.Save()
+ // SendTx.
+ {
+ stateSendTx := state.Copy(dbm.NewMemDB())
+ tx := &txs.SendTx{
+ Inputs: []*txs.TxInput{
+ {
+ Address: acc0.Address(),
+ Amount: 1,
+ Sequence: acc0.Sequence() + 1,
+ PublicKey: acc0PubKey,
+ },
+ },
+ Outputs: []*txs.TxOutput{
+ {
+ Address: acc1.Address(),
+ Amount: 1,
+ },
+ },
+ }
+
+ tx.Inputs[0].Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
+ err := execTxWithState(stateSendTx, tx)
+ if err != nil {
+ t.Errorf("Got error in executing send transaction, %v", err)
+ }
+ // uncomment for panic fun!
+ //stateSendTx.Save()
+ }
+
+ // CallTx. Just runs through it and checks the transfer. See vm, rpc tests for more
+ {
+ stateCallTx := state.Copy(dbm.NewMemDB())
+ newAcc1 := getAccount(stateCallTx, acc1.Address())
+ newAcc1.SetCode([]byte{0x60})
+ stateCallTx.UpdateAccount(newAcc1)
+ tx := &txs.CallTx{
+ Input: &txs.TxInput{
+ Address: acc0.Address(),
+ Amount: 1,
+ Sequence: acc0.Sequence() + 1,
+ PublicKey: acc0PubKey,
+ },
+ Address: addressPtr(acc1),
+ GasLimit: 10,
+ }
+
+ tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
+ err := execTxWithState(stateCallTx, tx)
+ if err != nil {
+ t.Errorf("Got error in executing call transaction, %v", err)
+ }
+ }
+ state.Save()
+ trygetacc0 := getAccount(state, privAccounts[0].Address())
+ fmt.Println(trygetacc0.Address())
+}
+
+// TODO: test overflows.
+// TODO: test for unbonding validators.
+func TestTxs(t *testing.T) {
+ state, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
+
+ //val0 := state.GetValidatorInfo(privValidators[0].Address())
+ acc0 := getAccount(state, privAccounts[0].Address())
+ acc0PubKey := privAccounts[0].PublicKey()
+ acc1 := getAccount(state, privAccounts[1].Address())
+
+ // SendTx.
+ {
+ stateSendTx := state.Copy(dbm.NewMemDB())
+ tx := &txs.SendTx{
+ Inputs: []*txs.TxInput{
+ {
+ Address: acc0.Address(),
+ Amount: 1,
+ Sequence: acc0.Sequence() + 1,
+ PublicKey: acc0PubKey,
+ },
+ },
+ Outputs: []*txs.TxOutput{
+ {
+ Address: acc1.Address(),
+ Amount: 1,
+ },
+ },
+ }
+
+ tx.Inputs[0].Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
+ err := execTxWithState(stateSendTx, tx)
+ if err != nil {
+ t.Errorf("Got error in executing send transaction, %v", err)
+ }
+ newAcc0 := getAccount(stateSendTx, acc0.Address())
+ if acc0.Balance()-1 != newAcc0.Balance() {
+ t.Errorf("Unexpected newAcc0 balance. Expected %v, got %v",
+ acc0.Balance()-1, newAcc0.Balance())
+ }
+ newAcc1 := getAccount(stateSendTx, acc1.Address())
+ if acc1.Balance()+1 != newAcc1.Balance() {
+ t.Errorf("Unexpected newAcc1 balance. Expected %v, got %v",
+ acc1.Balance()+1, newAcc1.Balance())
+ }
+ }
+
+ // CallTx. Just runs through it and checks the transfer. See vm, rpc tests for more
+ {
+ stateCallTx := state.Copy(dbm.NewMemDB())
+ newAcc1 := getAccount(stateCallTx, acc1.Address())
+ newAcc1.SetCode([]byte{0x60})
+ stateCallTx.UpdateAccount(newAcc1)
+ tx := &txs.CallTx{
+ Input: &txs.TxInput{
+ Address: acc0.Address(),
+ Amount: 1,
+ Sequence: acc0.Sequence() + 1,
+ PublicKey: acc0PubKey,
+ },
+ Address: addressPtr(acc1),
+ GasLimit: 10,
+ }
+
+ tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
+ err := execTxWithState(stateCallTx, tx)
+ if err != nil {
+ t.Errorf("Got error in executing call transaction, %v", err)
+ }
+ newAcc0 := getAccount(stateCallTx, acc0.Address())
+ if acc0.Balance()-1 != newAcc0.Balance() {
+ t.Errorf("Unexpected newAcc0 balance. Expected %v, got %v",
+ acc0.Balance()-1, newAcc0.Balance())
+ }
+ newAcc1 = getAccount(stateCallTx, acc1.Address())
+ if acc1.Balance()+1 != newAcc1.Balance() {
+ t.Errorf("Unexpected newAcc1 balance. Expected %v, got %v",
+ acc1.Balance()+1, newAcc1.Balance())
+ }
+ }
+ trygetacc0 := getAccount(state, privAccounts[0].Address())
+ fmt.Println(trygetacc0.Address())
+
+ // NameTx.
+ {
+ entryName := "satoshi"
+ entryData := `
+A purely peer-to-peer version of electronic cash would allow online
+payments to be sent directly from one party to another without going through a
+financial institution. Digital signatures provide part of the solution, but the main
+benefits are lost if a trusted third party is still required to prevent double-spending.
+We propose a solution to the double-spending problem using a peer-to-peer network.
+The network timestamps transactions by hashing them into an ongoing chain of
+hash-based proof-of-work, forming a record that cannot be changed without redoing
+the proof-of-work. The longest chain not only serves as proof of the sequence of
+events witnessed, but proof that it came from the largest pool of CPU power. As
+long as a majority of CPU power is controlled by nodes that are not cooperating to
+attack the network, they'll generate the longest chain and outpace attackers. The
+network itself requires minimal structure. Messages are broadcast on a best effort
+basis, and nodes can leave and rejoin the network at will, accepting the longest
+proof-of-work chain as proof of what happened while they were gone `
+ entryAmount := uint64(10000)
+
+ stateNameTx := state
+ tx := &txs.NameTx{
+ Input: &txs.TxInput{
+ Address: acc0.Address(),
+ Amount: entryAmount,
+ Sequence: acc0.Sequence() + 1,
+ PublicKey: acc0PubKey,
+ },
+ Name: entryName,
+ Data: entryData,
+ }
+
+ tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
+
+ err := execTxWithState(stateNameTx, tx)
+ if err != nil {
+ t.Errorf("Got error in executing call transaction, %v", err)
+ }
+ newAcc0 := getAccount(stateNameTx, acc0.Address())
+ if acc0.Balance()-entryAmount != newAcc0.Balance() {
+ t.Errorf("Unexpected newAcc0 balance. Expected %v, got %v",
+ acc0.Balance()-entryAmount, newAcc0.Balance())
+ }
+ entry, err := stateNameTx.GetNameRegEntry(entryName)
+ require.NoError(t, err)
+ if entry == nil {
+ t.Errorf("Expected an entry but got nil")
+ }
+ if entry.Data != entryData {
+ t.Errorf("Wrong data stored")
+ }
+
+ // test a bad string
+ tx.Data = string([]byte{0, 1, 2, 3, 127, 128, 129, 200, 251})
+ tx.Input.Sequence += 1
+ tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
+ err = execTxWithState(stateNameTx, tx)
+ if _, ok := err.(txs.ErrTxInvalidString); !ok {
+ t.Errorf("Expected invalid string error. Got: %s", err.Error())
+ }
+ }
+
+ // BondTx. TODO
+ /*
+ {
+ state := state.Copy()
+ tx := &txs.BondTx{
+ PublicKey: acc0PubKey.(acm.PublicKeyEd25519),
+ Inputs: []*txs.TxInput{
+ &txs.TxInput{
+ Address: acc0.Address(),
+ Amount: 1,
+ Sequence: acc0.Sequence() + 1,
+ PublicKey: acc0PubKey,
+ },
+ },
+ UnbondTo: []*txs.TxOutput{
+ &txs.TxOutput{
+ Address: acc0.Address(),
+ Amount: 1,
+ },
+ },
+ }
+ tx.Signature = privAccounts[0] acm.ChainSign(testChainID, tx).(crypto.SignatureEd25519)
+ tx.Inputs[0].Signature = privAccounts[0] acm.ChainSign(testChainID, tx)
+ err := execTxWithState(state, tx)
+ if err != nil {
+ t.Errorf("Got error in executing bond transaction, %v", err)
+ }
+ newAcc0 := getAccount(state, acc0.Address())
+ if newAcc0.Balance() != acc0.Balance()-1 {
+ t.Errorf("Unexpected newAcc0 balance. Expected %v, got %v",
+ acc0.Balance()-1, newAcc0.Balance())
+ }
+ _, acc0Val := state.BondedValidators.GetByAddress(acc0.Address())
+ if acc0Val == nil {
+ t.Errorf("acc0Val not present")
+ }
+ if acc0Val.BondHeight != blockchain.LastBlockHeight()+1 {
+ t.Errorf("Unexpected bond height. Expected %v, got %v",
+ blockchain.LastBlockHeight(), acc0Val.BondHeight)
+ }
+ if acc0Val.VotingPower != 1 {
+ t.Errorf("Unexpected voting power. Expected %v, got %v",
+ acc0Val.VotingPower, acc0.Balance())
+ }
+ if acc0Val.Accum != 0 {
+ t.Errorf("Unexpected accum. Expected 0, got %v",
+ acc0Val.Accum)
+ }
+ } */
+
+ // TODO UnbondTx.
+
+}
+
+func TestSelfDestruct(t *testing.T) {
+
+ state, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
+
+ acc0 := getAccount(state, privAccounts[0].Address())
+ acc0PubKey := privAccounts[0].PublicKey()
+ acc1 := getAccount(state, privAccounts[1].Address())
+ acc2 := getAccount(state, privAccounts[2].Address())
+ sendingAmount, refundedBalance, oldBalance := uint64(1), acc1.Balance(), acc2.Balance()
+
+ newAcc1 := getAccount(state, acc1.Address())
+
+ // store 0x1 at 0x1, push an address, then self-destruct:)
+ contractCode := []byte{0x60, 0x01, 0x60, 0x01, 0x55, 0x73}
+ contractCode = append(contractCode, acc2.Address().Bytes()...)
+ contractCode = append(contractCode, 0xff)
+ newAcc1.SetCode(contractCode)
+ state.UpdateAccount(newAcc1)
+
+ // send call tx with no data, cause self-destruct
+ tx := txs.NewCallTxWithSequence(acc0PubKey, addressPtr(acc1), nil, sendingAmount, 1000, 0, acc0.Sequence()+1)
+ tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
+
+ // we use cache instead of execTxWithState so we can run the tx twice
+ exe := NewBatchCommitter(state, testChainID, bcm.NewBlockchain(nil, testGenesisDoc), event.NewNoOpPublisher(), logger)
+ if err := exe.Execute(tx); err != nil {
+ t.Errorf("Got error in executing call transaction, %v", err)
+ }
+
+ // if we do it again, we won't get an error, but the self-destruct
+ // shouldn't happen twice and the caller should lose fee
+ tx.Input.Sequence += 1
+ tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
+ if err := exe.Execute(tx); err != nil {
+ t.Errorf("Got error in executing call transaction, %v", err)
+ }
+
+ // commit the block
+ exe.Commit()
+
+ // acc2 should receive the sent funds and the contracts balance
+ newAcc2 := getAccount(state, acc2.Address())
+ newBalance := sendingAmount + refundedBalance + oldBalance
+ if newAcc2.Balance() != newBalance {
+ t.Errorf("Unexpected newAcc2 balance. Expected %v, got %v",
+ newAcc2.Balance(), newBalance)
+ }
+ newAcc1 = getAccount(state, acc1.Address())
+ if newAcc1 != nil {
+ t.Errorf("Expected account to be removed")
+ }
+}
+
+func execTxWithStateAndBlockchain(state *State, tip bcm.Tip, tx txs.Tx) error {
+ exe := newExecutor(true, state, testChainID, tip, event.NewNoOpPublisher(), logger)
+ if err := exe.Execute(tx); err != nil {
+ return err
+ } else {
+ exe.Commit()
+ return nil
+ }
+}
+
+func execTxWithState(state *State, tx txs.Tx) error {
+ return execTxWithStateAndBlockchain(state, bcm.NewBlockchain(nil, testGenesisDoc), tx)
+}
+
+func commitNewBlock(state *State, blockchain bcm.MutableBlockchain) {
+ blockchain.CommitBlock(blockchain.LastBlockTime().Add(time.Second), sha3.Sha3(blockchain.LastBlockHash()),
+ state.Hash())
+}
+
+func execTxWithStateNewBlock(state *State, blockchain bcm.MutableBlockchain, tx txs.Tx) error {
+ if err := execTxWithStateAndBlockchain(state, blockchain, tx); err != nil {
+ return err
+ }
+ commitNewBlock(state, blockchain)
+ return nil
+}
+
+func makeGenesisState(numAccounts int, randBalance bool, minBalance uint64, numValidators int, randBonded bool,
+ minBonded int64) (*State, []acm.PrivateAccount) {
+ testGenesisDoc, privAccounts, _ := deterministicGenesis.GenesisDoc(numAccounts, randBalance, minBalance,
+ numValidators, randBonded, minBonded)
+ s0, err := MakeGenesisState(dbm.NewMemDB(), testGenesisDoc)
+ if err != nil {
+ panic(fmt.Errorf("could not make genesis state: %v", err))
+ }
+ s0.Save()
+ return s0, privAccounts
+}
+
+func getAccount(state acm.Getter, address acm.Address) acm.MutableAccount {
+ acc, _ := acm.GetMutableAccount(state, address)
+ return acc
+}
+
+func addressPtr(account acm.Account) *acm.Address {
+ if account == nil {
+ return nil
+ }
+ accountAddresss := account.Address()
+ return &accountAddresss
+}
+
//-------------------------------------------------------------------------------------
// helpers
@@ -1157,8 +1790,8 @@ func testSNativeCALL(t *testing.T, expectPass bool, batchCommitter *executor, do
doug.SetCode(callContractCode(snativeAddress))
dougAddress := doug.Address()
- batchCommitter.blockCache.UpdateAccount(doug)
- tx, _ := txs.NewCallTx(batchCommitter.blockCache, users[0].PublicKey(), &dougAddress, data, 100, 10000, 100)
+ batchCommitter.stateCache.UpdateAccount(doug)
+ tx, _ := txs.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &dougAddress, data, 100, 10000, 100)
tx.Sign(testChainID, users[0])
fmt.Println("subscribing to", evm_events.EventStringAccountCall(snativeAddress))
ev, exception := execTxWaitEvent(t, batchCommitter, tx, evm_events.EventStringAccountCall(snativeAddress))
@@ -1191,11 +1824,11 @@ func testSNativeTxExpectPass(t *testing.T, batchCommitter *executor, perm ptypes
func testSNativeTx(t *testing.T, expectPass bool, batchCommitter *executor, perm ptypes.PermFlag, snativeArgs permission.PermArgs) {
if expectPass {
- acc := getAccount(batchCommitter.blockCache, users[0].Address())
+ acc := getAccount(batchCommitter.stateCache, users[0].Address())
acc.MutablePermissions().Base.Set(perm, true)
- batchCommitter.blockCache.UpdateAccount(acc)
+ batchCommitter.stateCache.UpdateAccount(acc)
}
- tx, _ := txs.NewPermissionsTx(batchCommitter.blockCache, users[0].PublicKey(), snativeArgs)
+ tx, _ := txs.NewPermissionsTx(batchCommitter.stateCache, users[0].PublicKey(), snativeArgs)
tx.Sign(testChainID, users[0])
err := batchCommitter.Execute(tx)
if expectPass {
diff --git a/execution/namereg.go b/execution/namereg.go
index 4524882bf019942f03258eaa0aa31d4ec14aad0e..50babf2a15b60ae8f6d9143cbc3284c1bed9afd8 100644
--- a/execution/namereg.go
+++ b/execution/namereg.go
@@ -18,19 +18,34 @@ import "github.com/hyperledger/burrow/account"
// NameReg provides a global key value store based on Name, Data pairs that are subject to expiry and ownership by an
// account.
+type NameRegEntry struct {
+ // registered name for the entry
+ Name string
+ // address that created the entry
+ Owner account.Address
+ // data to store under this name
+ Data string
+ // block at which this entry expires
+ Expires uint64
+}
type NameRegGetter interface {
- GetNameRegEntry(name string) *NameRegEntry
+ GetNameRegEntry(name string) (*NameRegEntry, error)
}
-type NameRegIterable interface {
+type NameRegUpdater interface {
+ // Updates the name entry creating it if it does not exist
+ UpdateNameRegEntry(entry *NameRegEntry) error
+ // Remove the name entry
+ RemoveNameRegEntry(name string) error
+}
+
+type NameRegWriter interface {
NameRegGetter
- IterateNameRegEntries(consumer func(*NameRegEntry) (stop bool)) (stopped bool)
+ NameRegUpdater
}
-type NameRegEntry struct {
- Name string // registered name for the entry
- Owner account.Address // address that created the entry
- Data string // data to store under this name
- Expires uint64 // block at which this entry expires
+type NameRegIterable interface {
+ NameRegGetter
+ IterateNameRegEntries(consumer func(*NameRegEntry) (stop bool)) (stopped bool, err error)
}
diff --git a/execution/namereg_cache.go b/execution/namereg_cache.go
new file mode 100644
index 0000000000000000000000000000000000000000..f941b9f9ba370057153acd781f3a8cd6ce2496c9
--- /dev/null
+++ b/execution/namereg_cache.go
@@ -0,0 +1,165 @@
+// Copyright 2017 Monax Industries Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package execution
+
+import (
+ "fmt"
+ "sort"
+ "sync"
+)
+
+// The NameRegCache helps prevent unnecessary IAVLTree updates and garbage generation.
+type NameRegCache struct {
+ sync.RWMutex
+ backend NameRegGetter
+ names map[string]*nameInfo
+}
+
+type nameInfo struct {
+ sync.RWMutex
+ entry *NameRegEntry
+ removed bool
+ updated bool
+}
+
+var _ NameRegWriter = &NameRegCache{}
+
+// Returns a NameRegCache that wraps an underlying NameRegCacheGetter to use on a cache miss, can write to an
+// output NameRegWriter via Sync.
+// Not goroutine safe, use syncStateCache if you need concurrent access
+func NewNameRegCache(backend NameRegGetter) *NameRegCache {
+ return &NameRegCache{
+ backend: backend,
+ names: make(map[string]*nameInfo),
+ }
+}
+
+func (cache *NameRegCache) GetNameRegEntry(name string) (*NameRegEntry, error) {
+ nameInfo, err := cache.get(name)
+ if err != nil {
+ return nil, err
+ }
+ nameInfo.RLock()
+ defer nameInfo.RUnlock()
+ if nameInfo.removed {
+ return nil, nil
+ }
+ return nameInfo.entry, nil
+}
+
+func (cache *NameRegCache) UpdateNameRegEntry(entry *NameRegEntry) error {
+ nameInfo, err := cache.get(entry.Name)
+ if err != nil {
+ return err
+ }
+ nameInfo.Lock()
+ defer nameInfo.Unlock()
+ if nameInfo.removed {
+ return fmt.Errorf("UpdateNameRegEntry on a removed name: %s", nameInfo.entry.Name)
+ }
+
+ nameInfo.entry = entry
+ nameInfo.updated = true
+ return nil
+}
+
+func (cache *NameRegCache) RemoveNameRegEntry(name string) error {
+ nameInfo, err := cache.get(name)
+ if err != nil {
+ return err
+ }
+ nameInfo.Lock()
+ defer nameInfo.Unlock()
+ if nameInfo.removed {
+ return fmt.Errorf("RemoveNameRegEntry on removed name: %s", name)
+ }
+ nameInfo.removed = true
+ return nil
+}
+
+// Writes whatever is in the cache to the output NameRegWriter state. Does not flush the cache, to do that call Reset()
+// after Sync or use Flusth if your wish to use the output state as your next backend
+func (cache *NameRegCache) Sync(state NameRegWriter) error {
+ cache.Lock()
+ defer cache.Unlock()
+ // Determine order for names
+ // note names may be of any length less than some limit
+ var names sort.StringSlice
+ for nameStr := range cache.names {
+ names = append(names, nameStr)
+ }
+ sort.Stable(names)
+
+ // Update or delete names.
+ for _, name := range names {
+ nameInfo := cache.names[name]
+ nameInfo.RLock()
+ if nameInfo.removed {
+ err := state.RemoveNameRegEntry(name)
+ if err != nil {
+ return err
+ }
+ } else if nameInfo.updated {
+ err := state.UpdateNameRegEntry(nameInfo.entry)
+ if err != nil {
+ return err
+ }
+ }
+ nameInfo.RUnlock()
+ }
+ return nil
+}
+
+// Resets the cache to empty initialising the backing map to the same size as the previous iteration.
+func (cache *NameRegCache) Reset(backend NameRegGetter) {
+ cache.Lock()
+ defer cache.Unlock()
+ cache.backend = backend
+ cache.names = make(map[string]*nameInfo)
+}
+
+// Syncs the NameRegCache and Resets it to use NameRegWriter as the backend NameRegGetter
+func (cache *NameRegCache) Flush(state NameRegWriter) error {
+ err := cache.Sync(state)
+ if err != nil {
+ return err
+ }
+ cache.Reset(state)
+ return nil
+}
+
+func (cache *NameRegCache) Backend() NameRegGetter {
+ return cache.backend
+}
+
+// Get the cache accountInfo item creating it if necessary
+func (cache *NameRegCache) get(name string) (*nameInfo, error) {
+ cache.RLock()
+ nmeInfo := cache.names[name]
+ cache.RUnlock()
+ if nmeInfo == nil {
+ entry, err := cache.backend.GetNameRegEntry(name)
+ if err != nil {
+ return nil, err
+ }
+ nmeInfo = &nameInfo{
+ entry: entry,
+ }
+ cache.Lock()
+ cache.names[name] = nmeInfo
+ cache.Unlock()
+ }
+ return nmeInfo, nil
+}
diff --git a/execution/namereg_cache_test.go b/execution/namereg_cache_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..7671133b8d934c25bb9a8c531faeadd8a84d729a
--- /dev/null
+++ b/execution/namereg_cache_test.go
@@ -0,0 +1,39 @@
+// Copyright 2017 Monax Industries Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package execution
+
+import (
+ "testing"
+)
+
+// TODO: tests
+func TestNewNameRegCache(t *testing.T) {
+}
+
+func TestNameRegCache_GetNameRegEntry(t *testing.T) {
+}
+
+func TestNameRegCache_UpdateNameRegEntry(t *testing.T) {
+}
+
+func TestNameRegCache_RemoveNameRegEntry(t *testing.T) {
+}
+
+func TestNameRegCache_Sync(t *testing.T) {
+
+}
+
+func TestNameRegCache_get(t *testing.T) {
+}
diff --git a/execution/state.go b/execution/state.go
index 6928480b31bc9d30554a5da9c35d34d3c43a7147..7385267b3be6395b0b17dd6decddb9a4b0d4b01a 100644
--- a/execution/state.go
+++ b/execution/state.go
@@ -24,82 +24,89 @@ import (
acm "github.com/hyperledger/burrow/account"
"github.com/hyperledger/burrow/binary"
"github.com/hyperledger/burrow/genesis"
+ logging_types "github.com/hyperledger/burrow/logging/types"
"github.com/hyperledger/burrow/permission"
ptypes "github.com/hyperledger/burrow/permission"
"github.com/hyperledger/burrow/txs"
"github.com/tendermint/go-wire"
- "github.com/tendermint/merkleeyes/iavl"
+ "github.com/tendermint/iavl"
dbm "github.com/tendermint/tmlibs/db"
- "github.com/tendermint/tmlibs/merkle"
)
-var (
- stateKey = []byte("stateKey")
- minBondAmount = int64(1) // TODO adjust
- defaultAccountsCacheCapacity = 1000 // TODO adjust
- unbondingPeriodBlocks = int(60 * 24 * 365) // TODO probably better to make it time based.
- validatorTimeoutBlocks = int(10) // TODO adjust
- maxLoadStateElementSize = 0 // no max
-)
+const (
+ defaultCacheCapacity = 1024
-// TODO
-const GasLimit = uint64(1000000)
+ // Version by state hash
+ versionPrefix = "v/"
-//-----------------------------------------------------------------------------
+ // Prefix of keys in state tree
+ accountsPrefix = "a/"
+ storagePrefix = "s/"
+ nameRegPrefix = "n/"
+)
-// NOTE: not goroutine-safe.
-type State struct {
- sync.RWMutex
- db dbm.DB
- // BondedValidators *types.ValidatorSet
- // LastBondedValidators *types.ValidatorSet
- // UnbondingValidators *types.ValidatorSet
- accounts merkle.Tree // Shouldn't be accessed directly.
- validatorInfos merkle.Tree // Shouldn't be accessed directly.
- nameReg merkle.Tree // Shouldn't be accessed directly.
-}
+var (
+ accountsStart, accountsEnd []byte = prefixKeyRange(accountsPrefix)
+ storageStart, storageEnd []byte = prefixKeyRange(storagePrefix)
+ nameRegStart, nameRegEnd []byte = prefixKeyRange(nameRegPrefix)
+)
// Implements account and blockchain state
var _ acm.Updater = &State{}
-
var _ acm.StateIterable = &State{}
-
var _ acm.StateWriter = &State{}
-func MakeGenesisState(db dbm.DB, genDoc *genesis.GenesisDoc) (*State, error) {
- if len(genDoc.Validators) == 0 {
+type State struct {
+ sync.RWMutex
+ db dbm.DB
+ version uint64
+ // TODO:
+ tree *iavl.VersionedTree
+ logger logging_types.InfoTraceLogger
+}
+
+func NewState(db dbm.DB) *State {
+ return &State{
+ db: db,
+ tree: iavl.NewVersionedTree(defaultCacheCapacity, db),
+ }
+}
+
+// Make genesis state from GenesisDoc and save to DB
+func MakeGenesisState(db dbm.DB, genesisDoc *genesis.GenesisDoc) (*State, error) {
+ if len(genesisDoc.Validators) == 0 {
return nil, fmt.Errorf("the genesis file has no validators")
}
- if genDoc.GenesisTime.IsZero() {
+ state := NewState(db)
+
+ if genesisDoc.GenesisTime.IsZero() {
// NOTE: [ben] change GenesisTime to requirement on v0.17
// GenesisTime needs to be deterministic across the chain
// and should be required in the genesis file;
// the requirement is not yet enforced when lacking set
// time to 11/18/2016 @ 4:09am (UTC)
- genDoc.GenesisTime = time.Unix(1479442162, 0)
+ genesisDoc.GenesisTime = time.Unix(1479442162, 0)
}
// Make accounts state tree
- accounts := iavl.NewIAVLTree(defaultAccountsCacheCapacity, db)
- for _, genAcc := range genDoc.Accounts {
+ for _, genAcc := range genesisDoc.Accounts {
perm := genAcc.Permissions
acc := &acm.ConcreteAccount{
Address: genAcc.Address,
Balance: genAcc.Amount,
Permissions: perm,
}
- encodedAcc, err := acc.Encode()
+ err := state.UpdateAccount(acc.Account())
if err != nil {
return nil, err
}
- accounts.Set(acc.Address.Bytes(), encodedAcc)
}
// global permissions are saved as the 0 address
// so they are included in the accounts tree
globalPerms := ptypes.DefaultAccountPermissions
- globalPerms = genDoc.GlobalPermissions
+ globalPerms = genesisDoc.GlobalPermissions
// XXX: make sure the set bits are all true
// Without it the HasPermission() functions will fail
globalPerms.Base.SetBit = ptypes.AllPermFlags
@@ -109,143 +116,66 @@ func MakeGenesisState(db dbm.DB, genDoc *genesis.GenesisDoc) (*State, error) {
Balance: 1337,
Permissions: globalPerms,
}
- encodedPermsAcc, err := permsAcc.Encode()
+ err := state.UpdateAccount(permsAcc.Account())
if err != nil {
return nil, err
}
- accounts.Set(permsAcc.Address.Bytes(), encodedPermsAcc)
-
- // Make validatorInfos state tree && validators slice
- /*
- validatorInfos := merkle.NewIAVLTree(wire.BasicCodec, types.ValidatorInfoCodec, 0, db)
- validators := make([]*types.Validator, len(genDoc.Validators))
- for i, val := range genDoc.Validators {
- pubKey := val.PublicKey
- address := pubKey.Address()
-
- // Make ValidatorInfo
- valInfo := &types.ValidatorInfo{
- Address: address,
- PublicKey: pubKey,
- UnbondTo: make([]*types.TxOutput, len(val.UnbondTo)),
- FirstBondHeight: 0,
- FirstBondAmount: val.Amount,
- }
- for i, unbondTo := range val.UnbondTo {
- valInfo.UnbondTo[i] = &types.TxOutput{
- Address: unbondTo.Address,
- Amount: unbondTo.Amount,
- }
- }
- validatorInfos.Set(address, valInfo)
-
- // Make validator
- validators[i] = &types.Validator{
- Address: address,
- PublicKey: pubKey,
- VotingPower: val.Amount,
- }
- }
- */
-
- // Make namereg tree
- nameReg := iavl.NewIAVLTree(0, db)
- // TODO: add names, contracts to genesis.json
// IAVLTrees must be persisted before copy operations.
- accounts.Save()
- //validatorInfos.Save()
- nameReg.Save()
+ err = state.Save()
+ if err != nil {
+ return nil, err
+ }
+ return state, nil
- return &State{
- db: db,
- //BondedValidators: types.NewValidatorSet(validators),
- //LastBondedValidators: types.NewValidatorSet(nil),
- //UnbondingValidators: types.NewValidatorSet(nil),
- accounts: accounts,
- //validatorInfos: validatorInfos,
- nameReg: nameReg,
- }, nil
}
-func LoadState(db dbm.DB) (*State, error) {
- s := &State{db: db}
- buf := db.Get(stateKey)
- if len(buf) == 0 {
- return nil, nil
- } else {
- r, n, err := bytes.NewReader(buf), new(int), new(error)
- wire.ReadBinaryPtr(&s, r, 0, n, err)
- if *err != nil {
- // DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
- return nil, fmt.Errorf("data has been corrupted or its spec has changed: %v", *err)
- }
+// Tries to load the execution state from DB, returns nil with no error if no state found
+func LoadState(db dbm.DB, hash []byte) (*State, error) {
+ versionBytes := db.Get(prefixedKey(versionPrefix, hash))
+ if versionBytes == nil {
+ return nil, fmt.Errorf("could not retrieve version corresponding to state hash '%X' in database", hash)
+ }
+ state := NewState(db)
+ state.version = binary.GetUint64BE(versionBytes)
+ err := state.tree.Load()
+ if err != nil {
+ return nil, fmt.Errorf("could not load versioned state tree")
}
- return s, nil
+
+ if state.tree.LatestVersion() != state.version {
+ return nil, fmt.Errorf("state tree version %v expected for state hash %X but latest state tree version "+
+ "loaded is %v", state.version, hash, state.tree.LatestVersion())
+ }
+ return state, nil
}
-func (s *State) Save() {
+func (s *State) Save() error {
s.Lock()
defer s.Unlock()
- s.accounts.Save()
- //s.validatorInfos.Save()
- s.nameReg.Save()
- s.db.SetSync(stateKey, wire.BinaryBytes(s))
-}
-
-// CONTRACT:
-// Copy() is a cheap way to take a snapshot,
-// as if State were copied by value.
-// TODO [Silas]: Kill this with fire it is totally broken - there is no safe way to copy IAVLTree while sharing database
-func (s *State) Copy() *State {
- return &State{
- db: s.db,
- // BondedValidators: s.BondedValidators.Copy(), // TODO remove need for Copy() here.
- // LastBondedValidators: s.LastBondedValidators.Copy(), // That is, make updates to the validator set
- // UnbondingValidators: s.UnbondingValidators.Copy(), // copy the valSet lazily.
- accounts: s.accounts.Copy(),
- //validatorInfos: s.validatorInfos.Copy(),
- nameReg: s.nameReg.Copy(),
+ s.version++
+ hash, err := s.tree.SaveVersion(s.version)
+ if err != nil {
+ return err
}
+ versionBytes := make([]byte, 8)
+ binary.PutUint64BE(versionBytes, s.version)
+ s.db.SetSync(prefixedKey(versionPrefix, hash), versionBytes)
+ return nil
}
-//func (s *State) Copy() *State {
-// stateCopy := &State{
-// db: dbm.NewMemDB(),
-// chainID: s.chainID,
-// lastBlockHeight: s.lastBlockHeight,
-// lastBlockAppHash: s.lastBlockAppHash,
-// lastBlockTime: s.lastBlockTime,
-// // BondedValidators: s.BondedValidators.Copy(), // TODO remove need for Copy() here.
-// // LastBondedValidators: s.LastBondedValidators.Copy(), // That is, make updates to the validator set
-// // UnbondingValidators: s.UnbondingValidators.Copy(), // copy the valSet lazily.
-// accounts: copyTree(s.accounts),
-// //validatorInfos: s.validatorInfos.Copy(),
-// nameReg: copyTree(s.nameReg),
-// evc: nil,
-// }
-// stateCopy.Save()
-// return stateCopy
-//}
-
-// Returns a hash that represents the state data, excluding Last*
+// Computes the state hash, also computed on save where it is returned
func (s *State) Hash() []byte {
s.RLock()
defer s.RUnlock()
- return merkle.SimpleHashFromMap(map[string]interface{}{
- //"BondedValidators": s.BondedValidators,
- //"UnbondingValidators": s.UnbondingValidators,
- "Accounts": s.accounts.Hash(),
- //"ValidatorInfos": s.validatorInfos,
- "NameRegistry": s.nameReg,
- })
+ return s.tree.Hash()
}
// Returns nil if account does not exist with given address.
func (s *State) GetAccount(address acm.Address) (acm.Account, error) {
s.RLock()
defer s.RUnlock()
- _, accBytes, _ := s.accounts.Get(address.Bytes())
+ _, accBytes := s.tree.Get(prefixedKey(accountsPrefix, address.Bytes()))
if accBytes == nil {
return nil, nil
}
@@ -255,31 +185,29 @@ func (s *State) GetAccount(address acm.Address) (acm.Account, error) {
func (s *State) UpdateAccount(account acm.Account) error {
s.Lock()
defer s.Unlock()
- encodedAccount, err := account.Encode()
+ // TODO: find a way to implement something equivalent to this so we can set the account StorageRoot
+ //storageRoot := s.tree.SubTreeHash(prefixedKey(storagePrefix, account.Address().Bytes()))
+ // Alternatively just abandon and
+ accountWithStorageRoot := acm.AsMutableAccount(account).SetStorageRoot(nil)
+ encodedAccount, err := accountWithStorageRoot.Encode()
if err != nil {
return err
}
- s.accounts.Set(account.Address().Bytes(), encodedAccount)
+ s.tree.Set(prefixedKey(accountsPrefix, account.Address().Bytes()), encodedAccount)
return nil
}
func (s *State) RemoveAccount(address acm.Address) error {
s.Lock()
defer s.Unlock()
- s.accounts.Remove(address.Bytes())
+ s.tree.Remove(prefixedKey(accountsPrefix, address.Bytes()))
return nil
}
-// This does not give a true independent copy since the underlying database is shared and any save calls all copies
-// to become invalid and using them may cause panics
-func (s *State) GetAccounts() merkle.Tree {
- return s.accounts.Copy()
-}
-
func (s *State) IterateAccounts(consumer func(acm.Account) (stop bool)) (stopped bool, err error) {
s.RLock()
defer s.RUnlock()
- stopped = s.accounts.Iterate(func(key, value []byte) bool {
+ stopped = s.tree.IterateRange(accountsStart, accountsEnd, true, func(key, value []byte) bool {
var account acm.Account
account, err = acm.Decode(value)
if err != nil {
@@ -290,171 +218,26 @@ func (s *State) IterateAccounts(consumer func(acm.Account) (stop bool)) (stopped
return
}
-// State.accounts
-//-------------------------------------
-// State.validators
-
-// XXX: now handled by tendermint core
-
-/*
-
-// The returned ValidatorInfo is a copy, so mutating it
-// has no side effects.
-func (s *State) GetValidatorInfo(address []byte) *types.ValidatorInfo {
- _, valInfo := s.validatorInfos.Get(address)
- if valInfo == nil {
- return nil
- }
- return valInfo.(*types.ValidatorInfo).Copy()
-}
-
-// Returns false if new, true if updated.
-// The valInfo is copied before setting, so mutating it
-// afterwards has no side effects.
-func (s *State) SetValidatorInfo(valInfo *types.ValidatorInfo) (updated bool) {
- return s.validatorInfos.Set(valInfo.Address, valInfo.Copy())
-}
-
-func (s *State) GetValidatorInfos() merkle.Tree {
- return s.validatorInfos.Copy()
-}
-
-func (s *State) unbondValidator(val *types.Validator) {
- // Move validator to UnbondingValidators
- val, removed := s.BondedValidators.Remove(val.Address)
- if !removed {
- PanicCrisis("Couldn't remove validator for unbonding")
- }
- val.UnbondHeight = s.lastBlockHeight + 1
- added := s.UnbondingValidators.Add(val)
- if !added {
- PanicCrisis("Couldn't add validator for unbonding")
- }
-}
-
-func (s *State) rebondValidator(val *types.Validator) {
- // Move validator to BondingValidators
- val, removed := s.UnbondingValidators.Remove(val.Address)
- if !removed {
- PanicCrisis("Couldn't remove validator for rebonding")
- }
- val.BondHeight = s.lastBlockHeight + 1
- added := s.BondedValidators.Add(val)
- if !added {
- PanicCrisis("Couldn't add validator for rebonding")
- }
-}
-
-func (s *State) releaseValidator(val *types.Validator) {
- // Update validatorInfo
- valInfo := s.GetValidatorInfo(val.Address)
- if valInfo == nil {
- PanicSanity("Couldn't find validatorInfo for release")
- }
- valInfo.ReleasedHeight = s.lastBlockHeight + 1
- s.SetValidatorInfo(valInfo)
-
- // Send coins back to UnbondTo outputs
- accounts, err := getOrMakeOutputs(s, nil, valInfo.UnbondTo)
- if err != nil {
- PanicSanity("Couldn't get or make unbondTo accounts")
- }
- adjustByOutputs(accounts, valInfo.UnbondTo)
- for _, acc := range accounts {
- s.UpdateAccount(acc)
- }
-
- // Remove validator from UnbondingValidators
- _, removed := s.UnbondingValidators.Remove(val.Address)
- if !removed {
- PanicCrisis("Couldn't remove validator for release")
- }
-}
-
-func (s *State) destroyValidator(val *types.Validator) {
- // Update validatorInfo
- valInfo := s.GetValidatorInfo(val.Address)
- if valInfo == nil {
- PanicSanity("Couldn't find validatorInfo for release")
- }
- valInfo.DestroyedHeight = s.lastBlockHeight + 1
- valInfo.DestroyedAmount = val.VotingPower
- s.SetValidatorInfo(valInfo)
-
- // Remove validator
- _, removed := s.BondedValidators.Remove(val.Address)
- if !removed {
- _, removed := s.UnbondingValidators.Remove(val.Address)
- if !removed {
- PanicCrisis("Couldn't remove validator for destruction")
- }
- }
-
-}
-
-// Set the validator infos tree
-func (s *State) SetValidatorInfos(validatorInfos merkle.Tree) {
- s.validatorInfos = validatorInfos
-}
-
-*/
-
-// State.validators
-//-------------------------------------
-// State.storage
-
-func (s *State) accountStorage(address acm.Address) (merkle.Tree, error) {
- account, err := s.GetAccount(address)
- if err != nil {
- return nil, err
- }
- if account == nil {
- return nil, fmt.Errorf("could not find account %s to access its storage", address)
- }
- return s.LoadStorage(account.StorageRoot()), nil
-}
-
-func (s *State) LoadStorage(hash []byte) merkle.Tree {
- s.RLock()
- defer s.RUnlock()
- storage := iavl.NewIAVLTree(1024, s.db)
- storage.Load(hash)
- return storage
-}
-
func (s *State) GetStorage(address acm.Address, key binary.Word256) (binary.Word256, error) {
s.RLock()
defer s.RUnlock()
- storageTree, err := s.accountStorage(address)
- if err != nil {
- return binary.Zero256, err
- }
- _, value, _ := storageTree.Get(key.Bytes())
+ _, value := s.tree.Get(prefixedKey(storagePrefix, address.Bytes(), key.Bytes()))
return binary.LeftPadWord256(value), nil
}
func (s *State) SetStorage(address acm.Address, key, value binary.Word256) error {
s.Lock()
defer s.Unlock()
- storageTree, err := s.accountStorage(address)
- if err != nil {
- return err
- }
- if storageTree != nil {
- storageTree.Set(key.Bytes(), value.Bytes())
- }
+ s.tree.Set(prefixedKey(storagePrefix, address.Bytes(), key.Bytes()), value.Bytes())
return nil
}
func (s *State) IterateStorage(address acm.Address,
consumer func(key, value binary.Word256) (stop bool)) (stopped bool, err error) {
+ s.RLock()
+ defer s.RUnlock()
- var storageTree merkle.Tree
- storageTree, err = s.accountStorage(address)
- if err != nil {
- return
- }
- stopped = storageTree.Iterate(func(key []byte, value []byte) (stop bool) {
+ stopped = s.tree.IterateRange(storageStart, storageEnd, true, func(key []byte, value []byte) (stop bool) {
// Note: no left padding should occur unless there is a bug and non-words have been writte to this storage tree
if len(key) != binary.Word256Length {
err = fmt.Errorf("key '%X' stored for account %s is not a %v-byte word",
@@ -477,45 +260,55 @@ func (s *State) IterateStorage(address acm.Address,
var _ NameRegIterable = &State{}
-func (s *State) GetNameRegEntry(name string) *NameRegEntry {
- _, valueBytes, _ := s.nameReg.Get([]byte(name))
+func (s *State) GetNameRegEntry(name string) (*NameRegEntry, error) {
+ _, valueBytes := s.tree.Get(prefixedKey(nameRegPrefix, []byte(name)))
if valueBytes == nil {
- return nil
+ return nil, nil
}
- return DecodeNameRegEntry(valueBytes)
+ return DecodeNameRegEntry(valueBytes), nil
}
-func (s *State) IterateNameRegEntries(consumer func(*NameRegEntry) (stop bool)) (stopped bool) {
- return s.nameReg.Iterate(func(key []byte, value []byte) (stop bool) {
+func (s *State) IterateNameRegEntries(consumer func(*NameRegEntry) (stop bool)) (stopped bool, err error) {
+ return s.tree.IterateRange(nameRegStart, nameRegEnd, true, func(key []byte, value []byte) (stop bool) {
return consumer(DecodeNameRegEntry(value))
- })
-}
-
-func DecodeNameRegEntry(entryBytes []byte) *NameRegEntry {
- var n int
- var err error
- value := NameRegDecode(bytes.NewBuffer(entryBytes), &n, &err)
- return value.(*NameRegEntry)
+ }), nil
}
-func (s *State) UpdateNameRegEntry(entry *NameRegEntry) bool {
+func (s *State) UpdateNameRegEntry(entry *NameRegEntry) error {
w := new(bytes.Buffer)
var n int
var err error
NameRegEncode(entry, w, &n, &err)
- return s.nameReg.Set([]byte(entry.Name), w.Bytes())
+ if err != nil {
+ return err
+ }
+ s.tree.Set(prefixedKey(nameRegPrefix, []byte(entry.Name)), w.Bytes())
+ return nil
}
-func (s *State) RemoveNameRegEntry(name string) bool {
- _, removed := s.nameReg.Remove([]byte(name))
- return removed
+func (s *State) RemoveNameRegEntry(name string) error {
+ s.tree.Remove(prefixedKey(nameRegPrefix, []byte(name)))
+ return nil
+}
+
+// Creates a copy of the database to the supplied db
+func (s *State) Copy(db dbm.DB) *State {
+ state := NewState(db)
+ s.tree.Iterate(func(key []byte, value []byte) bool {
+ state.tree.Set(key, value)
+ return false
+ })
+ return state
}
-// Set the name reg tree
-func (s *State) SetNameReg(nameReg merkle.Tree) {
- s.nameReg = nameReg
+func DecodeNameRegEntry(entryBytes []byte) *NameRegEntry {
+ var n int
+ var err error
+ value := NameRegDecode(bytes.NewBuffer(entryBytes), &n, &err)
+ return value.(*NameRegEntry)
}
+
func NameRegEncode(o interface{}, w io.Writer, n *int, err *error) {
wire.WriteBinary(o.(*NameRegEntry), w, n, err)
}
@@ -523,3 +316,27 @@ func NameRegEncode(o interface{}, w io.Writer, n *int, err *error) {
func NameRegDecode(r io.Reader, n *int, err *error) interface{} {
return wire.ReadBinary(&NameRegEntry{}, r, txs.MaxDataLength, n, err)
}
+
+func prefixedKey(prefix string, suffices ...[]byte) []byte {
+ key := []byte(prefix)
+ for _, suffix := range suffices {
+ key = append(key, suffix...)
+ }
+ return key
+}
+
+// Returns the start key equal to the bytes of prefix and the end key which lexicographically above any key beginning
+// with prefix
+func prefixKeyRange(prefix string) (start, end []byte) {
+ start = []byte(prefix)
+ for i := len(start) - 1; i >= 0; i-- {
+ c := start[i]
+ if c < 0xff {
+ end = make([]byte, i+1)
+ copy(end, start)
+ end[i]++
+ return
+ }
+ }
+ return
+}
diff --git a/execution/state_test.go b/execution/state_test.go
index d7ee60be1288ec5529b4263d13de60b5bbe2a155..fb310574d557ffdb4b96abc0b07631678859c176 100644
--- a/execution/state_test.go
+++ b/execution/state_test.go
@@ -15,984 +15,18 @@
package execution
import (
- "bytes"
- "encoding/hex"
"testing"
- "fmt"
-
- "github.com/hyperledger/burrow/execution/evm/sha3"
- "github.com/stretchr/testify/require"
-
- "time"
-
acm "github.com/hyperledger/burrow/account"
- "github.com/hyperledger/burrow/binary"
- bcm "github.com/hyperledger/burrow/blockchain"
- "github.com/hyperledger/burrow/event"
- "github.com/hyperledger/burrow/genesis"
- "github.com/hyperledger/burrow/txs"
- "github.com/stretchr/testify/assert"
- dbm "github.com/tendermint/tmlibs/db"
+ "github.com/stretchr/testify/require"
+ "github.com/tendermint/tmlibs/db"
)
-var deterministicGenesis = genesis.NewDeterministicGenesis(34059836243380576)
-var testGenesisDoc, testPrivAccounts = deterministicGenesis.
- GenesisDoc(3, true, 1000, 1, true, 1000)
-var testChainID = testGenesisDoc.ChainID()
-
-func execTxWithStateAndBlockchain(state *State, tip bcm.Tip, tx txs.Tx) error {
- exe := newExecutor(true, state, testChainID, tip, event.NewNoOpPublisher(), logger)
- if err := exe.Execute(tx); err != nil {
- return err
- } else {
- exe.blockCache.Sync()
- return nil
- }
-}
-
-func execTxWithState(state *State, tx txs.Tx) error {
- return execTxWithStateAndBlockchain(state, bcm.NewBlockchain(testGenesisDoc), tx)
-}
-
-func commitNewBlock(state *State, blockchain bcm.MutableBlockchain) {
- blockchain.CommitBlock(blockchain.LastBlockTime().Add(time.Second), sha3.Sha3(blockchain.LastBlockHash()),
- state.Hash())
-}
-
-func execTxWithStateNewBlock(state *State, blockchain bcm.MutableBlockchain, tx txs.Tx) error {
- if err := execTxWithStateAndBlockchain(state, blockchain, tx); err != nil {
- return err
- }
- commitNewBlock(state, blockchain)
- return nil
-}
-
-func makeGenesisState(numAccounts int, randBalance bool, minBalance uint64, numValidators int, randBonded bool,
- minBonded int64) (*State, []acm.PrivateAccount) {
- testGenesisDoc, privAccounts := deterministicGenesis.GenesisDoc(numAccounts, randBalance, minBalance,
- numValidators, randBonded, minBonded)
- s0, err := MakeGenesisState(dbm.NewMemDB(), testGenesisDoc)
- if err != nil {
- panic(fmt.Errorf("could not make genesis state: %v", err))
- }
- s0.Save()
- return s0, privAccounts
-}
-
-func getAccount(state acm.Getter, address acm.Address) acm.MutableAccount {
- acc, _ := acm.GetMutableAccount(state, address)
- return acc
-}
-
-func addressPtr(account acm.Account) *acm.Address {
- if account == nil {
- return nil
- }
- accountAddresss := account.Address()
- return &accountAddresss
-}
-
-// Tests
-
-func TestCopyState(t *testing.T) {
- // Generate a random state
- s0, privAccounts := makeGenesisState(10, true, 1000, 5, true, 1000)
- s0Hash := s0.Hash()
- if len(s0Hash) == 0 {
- t.Error("Expected state hash")
- }
-
- // Check hash of copy
- s0Copy := s0.Copy()
- assert.Equal(t, s0Hash, s0Copy.Hash(), "Expected state copy hash to be the same")
- assert.Equal(t, s0Copy.Copy().Hash(), s0Copy.Hash(), "Expected COPY COPY COPY the same")
-
- // Mutate the original; hash should change.
- acc0Address := privAccounts[0].Address()
- acc := getAccount(s0, acc0Address)
- acc.AddToBalance(1)
-
- // The account balance shouldn't have changed yet.
- if getAccount(s0, acc0Address).Balance() == acc.Balance() {
- t.Error("Account balance changed unexpectedly")
- }
-
- // Setting, however, should change the balance.
- s0.UpdateAccount(acc)
- if getAccount(s0, acc0Address).Balance() != acc.Balance() {
- t.Error("Account balance wasn't set")
- }
-
- // Now that the state changed, the hash should change too.
- if bytes.Equal(s0Hash, s0.Hash()) {
- t.Error("Expected state hash to have changed")
- }
-
- // The s0Copy shouldn't have changed though.
- if !bytes.Equal(s0Hash, s0Copy.Hash()) {
- t.Error("Expected state copy hash to have not changed")
- }
-}
-
-/*
-func makeBlock(t *testing.T, state *State, validation *tmtypes.Commit, txs []txs.Tx) *tmtypes.Block {
- if validation == nil {
- validation = &tmtypes.Commit{}
- }
- block := &tmtypes.Block{
- Header: &tmtypes.Header{
- testChainID: testChainID,
- Height: blockchain.LastBlockHeight() + 1,
- Time: state.lastBlockTime.Add(time.Minute),
- NumTxs: len(txs),
- lastBlockAppHash: state.lastBlockAppHash,
- LastBlockParts: state.LastBlockParts,
- AppHash: nil,
- },
- LastCommit: validation,
- Data: &tmtypes.Data{
- Txs: txs,
- },
- }
- block.FillHeader()
-
- // Fill in block StateHash
- err := state.ComputeBlockStateHash(block)
- if err != nil {
- t.Error("Error appending initial block:", err)
- }
- if len(block.Header.StateHash) == 0 {
- t.Error("Expected StateHash but got nothing.")
- }
-
- return block
-}
-
-func TestGenesisSaveLoad(t *testing.T) {
-
- // Generate a state, save & load it.
- s0, _, _ := makeGenesisState(10, true, 1000, 5, true, 1000)
-
- // Make complete block and blockParts
- block := makeBlock(t, s0, nil, nil)
- blockParts := block.MakePartSet()
-
- // Now append the block to s0.
- err := ExecBlock(s0, block, blockParts.Header())
- if err != nil {
- t.Error("Error appending initial block:", err)
- }
-
- // Save s0
- s0.Save()
-
- // Sanity check s0
- //s0.db.(*dbm.MemDB).Print()
- if s0.BondedValidators.TotalVotingPower() == 0 {
- t.Error("s0 BondedValidators TotalVotingPower should not be 0")
- }
- if s0.lastBlockHeight != 1 {
- t.Error("s0 lastBlockHeight should be 1, got", s0.lastBlockHeight)
- }
-
- // Load s1
- s1 := LoadState(s0.db)
-
- // Compare height & blockHash
- if s0.lastBlockHeight != s1.lastBlockHeight {
- t.Error("lastBlockHeight mismatch")
- }
- if !bytes.Equal(s0.lastBlockAppHash, s1.lastBlockAppHash) {
- t.Error("lastBlockAppHash mismatch")
- }
-
- // Compare state merkle trees
- if s0.BondedValidators.Size() != s1.BondedValidators.Size() {
- t.Error("BondedValidators Size mismatch")
- }
- if s0.BondedValidators.TotalVotingPower() != s1.BondedValidators.TotalVotingPower() {
- t.Error("BondedValidators TotalVotingPower mismatch")
- }
- if !bytes.Equal(s0.BondedValidators.Hash(), s1.BondedValidators.Hash()) {
- t.Error("BondedValidators hash mismatch")
- }
- if s0.UnbondingValidators.Size() != s1.UnbondingValidators.Size() {
- t.Error("UnbondingValidators Size mismatch")
- }
- if s0.UnbondingValidators.TotalVotingPower() != s1.UnbondingValidators.TotalVotingPower() {
- t.Error("UnbondingValidators TotalVotingPower mismatch")
- }
- if !bytes.Equal(s0.UnbondingValidators.Hash(), s1.UnbondingValidators.Hash()) {
- t.Error("UnbondingValidators hash mismatch")
- }
- if !bytes.Equal(s0.accounts.Hash(), s1.accounts.Hash()) {
- t.Error("Accounts mismatch")
- }
- if !bytes.Equal(s0.validatorInfos.Hash(), s1.validatorInfos.Hash()) {
- t.Error("Accounts mismatch")
- }
-}
-*/
-
-func TestTxSequence(t *testing.T) {
-
- state, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
- acc0 := getAccount(state, privAccounts[0].Address())
- acc0PubKey := privAccounts[0].PublicKey()
- acc1 := getAccount(state, privAccounts[1].Address())
-
- // Test a variety of sequence numbers for the tx.
- // The tx should only pass when i == 1.
- for i := uint64(0); i < 3; i++ {
- sequence := acc0.Sequence() + i
- tx := txs.NewSendTx()
- tx.AddInputWithSequence(acc0PubKey, 1, sequence)
- tx.AddOutput(acc1.Address(), 1)
- tx.Inputs[0].Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
- stateCopy := state.Copy()
- err := execTxWithState(stateCopy, tx)
- if i == 1 {
- // Sequence is good.
- if err != nil {
- t.Errorf("Expected good sequence to pass: %v", err)
- }
- // Check acc.Sequence().
- newAcc0 := getAccount(stateCopy, acc0.Address())
- if newAcc0.Sequence() != sequence {
- t.Errorf("Expected account sequence to change to %v, got %v",
- sequence, newAcc0.Sequence())
- }
- } else {
- // Sequence is bad.
- if err == nil {
- t.Errorf("Expected bad sequence to fail")
- }
- // Check acc.Sequence(). (shouldn't have changed)
- newAcc0 := getAccount(stateCopy, acc0.Address())
- if newAcc0.Sequence() != acc0.Sequence() {
- t.Errorf("Expected account sequence to not change from %v, got %v",
- acc0.Sequence(), newAcc0.Sequence())
- }
- }
- }
-}
-
-func TestNameTxs(t *testing.T) {
- state, err := MakeGenesisState(dbm.NewMemDB(), testGenesisDoc)
+func TestState_UpdateAccount(t *testing.T) {
+ state := NewState(db.NewMemDB())
+ account := acm.NewConcreteAccountFromSecret("Foo").MutableAccount()
+ account.SetStorageRoot([]byte{2, 3, 4})
+ state.UpdateAccount(account)
+ err := state.Save()
require.NoError(t, err)
- state.Save()
-
- txs.MinNameRegistrationPeriod = 5
- blockchain := bcm.NewBlockchain(testGenesisDoc)
- startingBlock := blockchain.LastBlockHeight()
-
- // try some bad names. these should all fail
- names := []string{"", "\n", "123#$%", "\x00", string([]byte{20, 40, 60, 80}),
- "baffledbythespectacleinallofthisyouseeehesaidwithouteyessurprised", "no spaces please"}
- data := "something about all this just doesn't feel right."
- fee := uint64(1000)
- numDesiredBlocks := uint64(5)
- for _, name := range names {
- amt := fee + numDesiredBlocks*txs.NameByteCostMultiplier*txs.NameBlockCostMultiplier*
- txs.NameBaseCost(name, data)
- tx, _ := txs.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
- tx.Sign(testChainID, testPrivAccounts[0])
-
- if err := execTxWithState(state, tx); err == nil {
- t.Fatalf("Expected invalid name error from %s", name)
- }
- }
-
- // try some bad data. these should all fail
- name := "hold_it_chum"
- datas := []string{"cold&warm", "!@#$%^&*()", "<<<>>>>", "because why would you ever need a ~ or a & or even a % in a json file? make your case and we'll talk"}
- for _, data := range datas {
- amt := fee + numDesiredBlocks*txs.NameByteCostMultiplier*txs.NameBlockCostMultiplier*
- txs.NameBaseCost(name, data)
- tx, _ := txs.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
- tx.Sign(testChainID, testPrivAccounts[0])
-
- if err := execTxWithState(state, tx); err == nil {
- t.Fatalf("Expected invalid data error from %s", data)
- }
- }
-
- validateEntry := func(t *testing.T, entry *NameRegEntry, name, data string, addr acm.Address, expires uint64) {
-
- if entry == nil {
- t.Fatalf("Could not find name %s", name)
- }
- if entry.Owner != addr {
- t.Fatalf("Wrong owner. Got %s expected %s", entry.Owner, addr)
- }
- if data != entry.Data {
- t.Fatalf("Wrong data. Got %s expected %s", entry.Data, data)
- }
- if name != entry.Name {
- t.Fatalf("Wrong name. Got %s expected %s", entry.Name, name)
- }
- if expires != entry.Expires {
- t.Fatalf("Wrong expiry. Got %d, expected %d", entry.Expires, expires)
- }
- }
-
- // try a good one, check data, owner, expiry
- name = "@looking_good/karaoke_bar.broadband"
- data = "on this side of neptune there are 1234567890 people: first is OMNIVORE+-3. Or is it. Ok this is pretty restrictive. No exclamations :(. Faces tho :')"
- amt := fee + numDesiredBlocks*txs.NameByteCostMultiplier*txs.NameBlockCostMultiplier*txs.NameBaseCost(name, data)
- tx, _ := txs.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
- tx.Sign(testChainID, testPrivAccounts[0])
- if err := execTxWithState(state, tx); err != nil {
- t.Fatal(err)
- }
- entry := state.GetNameRegEntry(name)
- validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), startingBlock+numDesiredBlocks)
-
- // fail to update it as non-owner, in same block
- tx, _ = txs.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
- tx.Sign(testChainID, testPrivAccounts[1])
- if err := execTxWithState(state, tx); err == nil {
- t.Fatal("Expected error")
- }
-
- // update it as owner, just to increase expiry, in same block
- // NOTE: we have to resend the data or it will clear it (is this what we want?)
- tx, _ = txs.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
- tx.Sign(testChainID, testPrivAccounts[0])
- if err := execTxWithStateNewBlock(state, blockchain, tx); err != nil {
- t.Fatal(err)
- }
- entry = state.GetNameRegEntry(name)
- validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), startingBlock+numDesiredBlocks*2)
-
- // update it as owner, just to increase expiry, in next block
- tx, _ = txs.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
- tx.Sign(testChainID, testPrivAccounts[0])
- if err := execTxWithStateNewBlock(state, blockchain, tx); err != nil {
- t.Fatal(err)
- }
- entry = state.GetNameRegEntry(name)
- validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), startingBlock+numDesiredBlocks*3)
-
- // fail to update it as non-owner
- // Fast forward
- for blockchain.Tip().LastBlockHeight() < entry.Expires-1 {
- commitNewBlock(state, blockchain)
- }
- tx, _ = txs.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
- tx.Sign(testChainID, testPrivAccounts[1])
- if err := execTxWithStateAndBlockchain(state, blockchain, tx); err == nil {
- t.Fatal("Expected error")
- }
- commitNewBlock(state, blockchain)
-
- // once expires, non-owner succeeds
- tx, _ = txs.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
- tx.Sign(testChainID, testPrivAccounts[1])
- if err := execTxWithStateAndBlockchain(state, blockchain, tx); err != nil {
- t.Fatal(err)
- }
- entry = state.GetNameRegEntry(name)
- validateEntry(t, entry, name, data, testPrivAccounts[1].Address(), blockchain.LastBlockHeight()+numDesiredBlocks)
-
- // update it as new owner, with new data (longer), but keep the expiry!
- data = "In the beginning there was no thing, not even the beginning. It hadn't been here, no there, nor for that matter anywhere, not especially because it had not to even exist, let alone to not. Nothing especially odd about that."
- oldCredit := amt - fee
- numDesiredBlocks = 10
- amt = fee + numDesiredBlocks*txs.NameByteCostMultiplier*txs.NameBlockCostMultiplier*txs.NameBaseCost(name, data) - oldCredit
- tx, _ = txs.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
- tx.Sign(testChainID, testPrivAccounts[1])
- if err := execTxWithStateAndBlockchain(state, blockchain, tx); err != nil {
- t.Fatal(err)
- }
- entry = state.GetNameRegEntry(name)
- validateEntry(t, entry, name, data, testPrivAccounts[1].Address(), blockchain.LastBlockHeight()+numDesiredBlocks)
-
- // test removal
- amt = fee
- data = ""
- tx, _ = txs.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
- tx.Sign(testChainID, testPrivAccounts[1])
- if err := execTxWithStateNewBlock(state, blockchain, tx); err != nil {
- t.Fatal(err)
- }
- entry = state.GetNameRegEntry(name)
- if entry != nil {
- t.Fatal("Expected removed entry to be nil")
- }
-
- // create entry by key0,
- // test removal by key1 after expiry
- name = "looking_good/karaoke_bar"
- data = "some data"
- amt = fee + numDesiredBlocks*txs.NameByteCostMultiplier*txs.NameBlockCostMultiplier*txs.NameBaseCost(name, data)
- tx, _ = txs.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
- tx.Sign(testChainID, testPrivAccounts[0])
- if err := execTxWithStateAndBlockchain(state, blockchain, tx); err != nil {
- t.Fatal(err)
- }
- entry = state.GetNameRegEntry(name)
- validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), blockchain.LastBlockHeight()+numDesiredBlocks)
- // Fast forward
- for blockchain.Tip().LastBlockHeight() < entry.Expires {
- commitNewBlock(state, blockchain)
- }
-
- amt = fee
- data = ""
- tx, _ = txs.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
- tx.Sign(testChainID, testPrivAccounts[1])
- if err := execTxWithStateNewBlock(state, blockchain, tx); err != nil {
- t.Fatal(err)
- }
- entry = state.GetNameRegEntry(name)
- if entry != nil {
- t.Fatal("Expected removed entry to be nil")
- }
-}
-
-// Test creating a contract from futher down the call stack
-/*
-contract Factory {
- address a;
- function create() returns (address){
- a = new PreFactory();
- return a;
- }
-}
-
-contract PreFactory{
- address a;
- function create(Factory c) returns (address) {
- a = c.create();
- return a;
- }
-}
-*/
-
-// run-time byte code for each of the above
-var preFactoryCode, _ = hex.DecodeString("60606040526000357C0100000000000000000000000000000000000000000000000000000000900480639ED933181461003957610037565B005B61004F600480803590602001909190505061007B565B604051808273FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF16815260200191505060405180910390F35B60008173FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF1663EFC81A8C604051817C01000000000000000000000000000000000000000000000000000000000281526004018090506020604051808303816000876161DA5A03F1156100025750505060405180519060200150600060006101000A81548173FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF02191690830217905550600060009054906101000A900473FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF16905061013C565B91905056")
-var factoryCode, _ = hex.DecodeString("60606040526000357C010000000000000000000000000000000000000000000000000000000090048063EFC81A8C146037576035565B005B60426004805050606E565B604051808273FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF16815260200191505060405180910390F35B6000604051610153806100E0833901809050604051809103906000F0600060006101000A81548173FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF02191690830217905550600060009054906101000A900473FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF16905060DD565B90566060604052610141806100126000396000F360606040526000357C0100000000000000000000000000000000000000000000000000000000900480639ED933181461003957610037565B005B61004F600480803590602001909190505061007B565B604051808273FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF16815260200191505060405180910390F35B60008173FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF1663EFC81A8C604051817C01000000000000000000000000000000000000000000000000000000000281526004018090506020604051808303816000876161DA5A03F1156100025750505060405180519060200150600060006101000A81548173FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF02191690830217905550600060009054906101000A900473FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF16905061013C565B91905056")
-var createData, _ = hex.DecodeString("9ed93318")
-
-func TestCreates(t *testing.T) {
- //evm.SetDebug(true)
- state, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
-
- //val0 := state.GetValidatorInfo(privValidators[0].Address())
- acc0 := getAccount(state, privAccounts[0].Address())
- acc0PubKey := privAccounts[0].PublicKey()
- acc1 := getAccount(state, privAccounts[1].Address())
- acc2 := getAccount(state, privAccounts[2].Address())
-
- state = state.Copy()
- newAcc1 := getAccount(state, acc1.Address())
- newAcc1.SetCode(preFactoryCode)
- newAcc2 := getAccount(state, acc2.Address())
- newAcc2.SetCode(factoryCode)
-
- state.UpdateAccount(newAcc1)
- state.UpdateAccount(newAcc2)
-
- createData = append(createData, acc2.Address().Word256().Bytes()...)
-
- // call the pre-factory, triggering the factory to run a create
- tx := &txs.CallTx{
- Input: &txs.TxInput{
- Address: acc0.Address(),
- Amount: 1,
- Sequence: acc0.Sequence() + 1,
- PublicKey: acc0PubKey,
- },
- Address: addressPtr(acc1),
- GasLimit: 10000,
- Data: createData,
- }
-
- tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
- err := execTxWithState(state, tx)
- if err != nil {
- t.Errorf("Got error in executing call transaction, %v", err)
- }
-
- acc1 = getAccount(state, acc1.Address())
- storage := state.LoadStorage(acc1.StorageRoot())
- _, firstCreatedAddress, _ := storage.Get(binary.LeftPadBytes([]byte{0}, 32))
-
- acc0 = getAccount(state, acc0.Address())
- // call the pre-factory, triggering the factory to run a create
- tx = &txs.CallTx{
- Input: &txs.TxInput{
- Address: acc0.Address(),
- Amount: 1,
- Sequence: acc0.Sequence() + 1,
- PublicKey: acc0PubKey,
- },
- Address: addressPtr(acc1),
- GasLimit: 100000,
- Data: createData,
- }
-
- tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
- err = execTxWithState(state, tx)
- if err != nil {
- t.Errorf("Got error in executing call transaction, %v", err)
- }
-
- acc1 = getAccount(state, acc1.Address())
- storage = state.LoadStorage(acc1.StorageRoot())
- _, secondCreatedAddress, _ := storage.Get(binary.LeftPadBytes([]byte{0}, 32))
-
- if bytes.Equal(firstCreatedAddress, secondCreatedAddress) {
- t.Errorf("Multiple contracts created with the same address!")
- }
-}
-
-/*
-contract Caller {
- function send(address x){
- x.send(msg.value);
- }
-}
-*/
-var callerCode, _ = hex.DecodeString("60606040526000357c0100000000000000000000000000000000000000000000000000000000900480633e58c58c146037576035565b005b604b6004808035906020019091905050604d565b005b8073ffffffffffffffffffffffffffffffffffffffff16600034604051809050600060405180830381858888f19350505050505b5056")
-var sendData, _ = hex.DecodeString("3e58c58c")
-
-func TestContractSend(t *testing.T) {
- state, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
-
- //val0 := state.GetValidatorInfo(privValidators[0].Address())
- acc0 := getAccount(state, privAccounts[0].Address())
- acc0PubKey := privAccounts[0].PublicKey()
- acc1 := getAccount(state, privAccounts[1].Address())
- acc2 := getAccount(state, privAccounts[2].Address())
-
- state = state.Copy()
- newAcc1 := getAccount(state, acc1.Address())
- newAcc1.SetCode(callerCode)
- state.UpdateAccount(newAcc1)
-
- sendData = append(sendData, acc2.Address().Word256().Bytes()...)
- sendAmt := uint64(10)
- acc2Balance := acc2.Balance()
-
- // call the contract, triggering the send
- tx := &txs.CallTx{
- Input: &txs.TxInput{
- Address: acc0.Address(),
- Amount: sendAmt,
- Sequence: acc0.Sequence() + 1,
- PublicKey: acc0PubKey,
- },
- Address: addressPtr(acc1),
- GasLimit: 1000,
- Data: sendData,
- }
-
- tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
- err := execTxWithState(state, tx)
- if err != nil {
- t.Errorf("Got error in executing call transaction, %v", err)
- }
-
- acc2 = getAccount(state, acc2.Address())
- if acc2.Balance() != sendAmt+acc2Balance {
- t.Errorf("Value transfer from contract failed! Got %d, expected %d", acc2.Balance(), sendAmt+acc2Balance)
- }
-}
-func TestMerklePanic(t *testing.T) {
- state, privAccounts := makeGenesisState(3, true, 1000, 1, true,
- 1000)
-
- //val0 := state.GetValidatorInfo(privValidators[0].Address())
- acc0 := getAccount(state, privAccounts[0].Address())
- acc0PubKey := privAccounts[0].PublicKey()
- acc1 := getAccount(state, privAccounts[1].Address())
-
- state.Save()
- // SendTx.
- {
- stateSendTx := state.Copy()
- tx := &txs.SendTx{
- Inputs: []*txs.TxInput{
- {
- Address: acc0.Address(),
- Amount: 1,
- Sequence: acc0.Sequence() + 1,
- PublicKey: acc0PubKey,
- },
- },
- Outputs: []*txs.TxOutput{
- {
- Address: acc1.Address(),
- Amount: 1,
- },
- },
- }
-
- tx.Inputs[0].Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
- err := execTxWithState(stateSendTx, tx)
- if err != nil {
- t.Errorf("Got error in executing send transaction, %v", err)
- }
- // uncomment for panic fun!
- //stateSendTx.Save()
- }
-
- // CallTx. Just runs through it and checks the transfer. See vm, rpc tests for more
- {
- stateCallTx := state.Copy()
- newAcc1 := getAccount(stateCallTx, acc1.Address())
- newAcc1.SetCode([]byte{0x60})
- stateCallTx.UpdateAccount(newAcc1)
- tx := &txs.CallTx{
- Input: &txs.TxInput{
- Address: acc0.Address(),
- Amount: 1,
- Sequence: acc0.Sequence() + 1,
- PublicKey: acc0PubKey,
- },
- Address: addressPtr(acc1),
- GasLimit: 10,
- }
-
- tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
- err := execTxWithState(stateCallTx, tx)
- if err != nil {
- t.Errorf("Got error in executing call transaction, %v", err)
- }
- }
- state.Save()
- trygetacc0 := getAccount(state, privAccounts[0].Address())
- fmt.Println(trygetacc0.Address())
-}
-
-// TODO: test overflows.
-// TODO: test for unbonding validators.
-func TestTxs(t *testing.T) {
- state, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
-
- //val0 := state.GetValidatorInfo(privValidators[0].Address())
- acc0 := getAccount(state, privAccounts[0].Address())
- acc0PubKey := privAccounts[0].PublicKey()
- acc1 := getAccount(state, privAccounts[1].Address())
-
- // SendTx.
- {
- stateSendTx := state.Copy()
- tx := &txs.SendTx{
- Inputs: []*txs.TxInput{
- {
- Address: acc0.Address(),
- Amount: 1,
- Sequence: acc0.Sequence() + 1,
- PublicKey: acc0PubKey,
- },
- },
- Outputs: []*txs.TxOutput{
- {
- Address: acc1.Address(),
- Amount: 1,
- },
- },
- }
-
- tx.Inputs[0].Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
- err := execTxWithState(stateSendTx, tx)
- if err != nil {
- t.Errorf("Got error in executing send transaction, %v", err)
- }
- newAcc0 := getAccount(stateSendTx, acc0.Address())
- if acc0.Balance()-1 != newAcc0.Balance() {
- t.Errorf("Unexpected newAcc0 balance. Expected %v, got %v",
- acc0.Balance()-1, newAcc0.Balance())
- }
- newAcc1 := getAccount(stateSendTx, acc1.Address())
- if acc1.Balance()+1 != newAcc1.Balance() {
- t.Errorf("Unexpected newAcc1 balance. Expected %v, got %v",
- acc1.Balance()+1, newAcc1.Balance())
- }
- }
-
- // CallTx. Just runs through it and checks the transfer. See vm, rpc tests for more
- {
- stateCallTx := state.Copy()
- newAcc1 := getAccount(stateCallTx, acc1.Address())
- newAcc1.SetCode([]byte{0x60})
- stateCallTx.UpdateAccount(newAcc1)
- tx := &txs.CallTx{
- Input: &txs.TxInput{
- Address: acc0.Address(),
- Amount: 1,
- Sequence: acc0.Sequence() + 1,
- PublicKey: acc0PubKey,
- },
- Address: addressPtr(acc1),
- GasLimit: 10,
- }
-
- tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
- err := execTxWithState(stateCallTx, tx)
- if err != nil {
- t.Errorf("Got error in executing call transaction, %v", err)
- }
- newAcc0 := getAccount(stateCallTx, acc0.Address())
- if acc0.Balance()-1 != newAcc0.Balance() {
- t.Errorf("Unexpected newAcc0 balance. Expected %v, got %v",
- acc0.Balance()-1, newAcc0.Balance())
- }
- newAcc1 = getAccount(stateCallTx, acc1.Address())
- if acc1.Balance()+1 != newAcc1.Balance() {
- t.Errorf("Unexpected newAcc1 balance. Expected %v, got %v",
- acc1.Balance()+1, newAcc1.Balance())
- }
- }
- trygetacc0 := getAccount(state, privAccounts[0].Address())
- fmt.Println(trygetacc0.Address())
-
- // NameTx.
- {
- entryName := "satoshi"
- entryData := `
-A purely peer-to-peer version of electronic cash would allow online
-payments to be sent directly from one party to another without going through a
-financial institution. Digital signatures provide part of the solution, but the main
-benefits are lost if a trusted third party is still required to prevent double-spending.
-We propose a solution to the double-spending problem using a peer-to-peer network.
-The network timestamps transactions by hashing them into an ongoing chain of
-hash-based proof-of-work, forming a record that cannot be changed without redoing
-the proof-of-work. The longest chain not only serves as proof of the sequence of
-events witnessed, but proof that it came from the largest pool of CPU power. As
-long as a majority of CPU power is controlled by nodes that are not cooperating to
-attack the network, they'll generate the longest chain and outpace attackers. The
-network itself requires minimal structure. Messages are broadcast on a best effort
-basis, and nodes can leave and rejoin the network at will, accepting the longest
-proof-of-work chain as proof of what happened while they were gone `
- entryAmount := uint64(10000)
-
- stateNameTx := state.Copy()
- tx := &txs.NameTx{
- Input: &txs.TxInput{
- Address: acc0.Address(),
- Amount: entryAmount,
- Sequence: acc0.Sequence() + 1,
- PublicKey: acc0PubKey,
- },
- Name: entryName,
- Data: entryData,
- }
-
- tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
-
- err := execTxWithState(stateNameTx, tx)
- if err != nil {
- t.Errorf("Got error in executing call transaction, %v", err)
- }
- newAcc0 := getAccount(stateNameTx, acc0.Address())
- if acc0.Balance()-entryAmount != newAcc0.Balance() {
- t.Errorf("Unexpected newAcc0 balance. Expected %v, got %v",
- acc0.Balance()-entryAmount, newAcc0.Balance())
- }
- entry := stateNameTx.GetNameRegEntry(entryName)
- if entry == nil {
- t.Errorf("Expected an entry but got nil")
- }
- if entry.Data != entryData {
- t.Errorf("Wrong data stored")
- }
-
- // test a bad string
- tx.Data = string([]byte{0, 1, 2, 3, 127, 128, 129, 200, 251})
- tx.Input.Sequence += 1
- tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
- err = execTxWithState(stateNameTx, tx)
- if _, ok := err.(txs.ErrTxInvalidString); !ok {
- t.Errorf("Expected invalid string error. Got: %s", err.Error())
- }
- }
-
- // BondTx. TODO
- /*
- {
- state := state.Copy()
- tx := &txs.BondTx{
- PublicKey: acc0PubKey.(acm.PublicKeyEd25519),
- Inputs: []*txs.TxInput{
- &txs.TxInput{
- Address: acc0.Address(),
- Amount: 1,
- Sequence: acc0.Sequence() + 1,
- PublicKey: acc0PubKey,
- },
- },
- UnbondTo: []*txs.TxOutput{
- &txs.TxOutput{
- Address: acc0.Address(),
- Amount: 1,
- },
- },
- }
- tx.Signature = privAccounts[0] acm.ChainSign(testChainID, tx).(crypto.SignatureEd25519)
- tx.Inputs[0].Signature = privAccounts[0] acm.ChainSign(testChainID, tx)
- err := execTxWithState(state, tx)
- if err != nil {
- t.Errorf("Got error in executing bond transaction, %v", err)
- }
- newAcc0 := getAccount(state, acc0.Address())
- if newAcc0.Balance() != acc0.Balance()-1 {
- t.Errorf("Unexpected newAcc0 balance. Expected %v, got %v",
- acc0.Balance()-1, newAcc0.Balance())
- }
- _, acc0Val := state.BondedValidators.GetByAddress(acc0.Address())
- if acc0Val == nil {
- t.Errorf("acc0Val not present")
- }
- if acc0Val.BondHeight != blockchain.LastBlockHeight()+1 {
- t.Errorf("Unexpected bond height. Expected %v, got %v",
- blockchain.LastBlockHeight(), acc0Val.BondHeight)
- }
- if acc0Val.VotingPower != 1 {
- t.Errorf("Unexpected voting power. Expected %v, got %v",
- acc0Val.VotingPower, acc0.Balance())
- }
- if acc0Val.Accum != 0 {
- t.Errorf("Unexpected accum. Expected 0, got %v",
- acc0Val.Accum)
- }
- } */
-
- // TODO UnbondTx.
-
-}
-
-func TestSelfDestruct(t *testing.T) {
-
- state, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
-
- acc0 := getAccount(state, privAccounts[0].Address())
- acc0PubKey := privAccounts[0].PublicKey()
- acc1 := getAccount(state, privAccounts[1].Address())
- acc2 := getAccount(state, privAccounts[2].Address())
- sendingAmount, refundedBalance, oldBalance := uint64(1), acc1.Balance(), acc2.Balance()
-
- newAcc1 := getAccount(state, acc1.Address())
-
- // store 0x1 at 0x1, push an address, then self-destruct:)
- contractCode := []byte{0x60, 0x01, 0x60, 0x01, 0x55, 0x73}
- contractCode = append(contractCode, acc2.Address().Bytes()...)
- contractCode = append(contractCode, 0xff)
- newAcc1.SetCode(contractCode)
- state.UpdateAccount(newAcc1)
-
- // send call tx with no data, cause self-destruct
- tx := txs.NewCallTxWithSequence(acc0PubKey, addressPtr(acc1), nil, sendingAmount, 1000, 0, acc0.Sequence()+1)
- tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
-
- // we use cache instead of execTxWithState so we can run the tx twice
- exe := NewBatchCommitter(state, testChainID, bcm.NewBlockchain(testGenesisDoc), event.NewNoOpPublisher(), logger)
- if err := exe.Execute(tx); err != nil {
- t.Errorf("Got error in executing call transaction, %v", err)
- }
-
- // if we do it again, we won't get an error, but the self-destruct
- // shouldn't happen twice and the caller should lose fee
- tx.Input.Sequence += 1
- tx.Input.Signature = acm.ChainSign(privAccounts[0], testChainID, tx)
- if err := exe.Execute(tx); err != nil {
- t.Errorf("Got error in executing call transaction, %v", err)
- }
-
- // commit the block
- exe.Commit()
-
- // acc2 should receive the sent funds and the contracts balance
- newAcc2 := getAccount(state, acc2.Address())
- newBalance := sendingAmount + refundedBalance + oldBalance
- if newAcc2.Balance() != newBalance {
- t.Errorf("Unexpected newAcc2 balance. Expected %v, got %v",
- newAcc2.Balance(), newBalance)
- }
- newAcc1 = getAccount(state, acc1.Address())
- if newAcc1 != nil {
- t.Errorf("Expected account to be removed")
- }
-
-}
-
-/* TODO
-func TestAddValidator(t *testing.T) {
-
- // Generate a state, save & load it.
- s0, privAccounts, privValidators := makeGenesisState(10, false, 1000, 1, false, 1000)
-
- // The first privAccount will become a validator
- acc0 := privAccounts[0]
- bondTx := &txs.BondTx{
- PublicKey: acc0.PublicKey.(account.PubKeyEd25519),
- Inputs: []*txs.TxInput{
- &txs.TxInput{
- Address: acc0.Address(),
- Amount: 1000,
- Sequence: 1,
- PublicKey: acc0.PublicKey,
- },
- },
- UnbondTo: []*txs.TxOutput{
- &txs.TxOutput{
- Address: acc0.Address(),
- Amount: 1000,
- },
- },
- }
- bondTx.Signature = acc0 acm.ChainSign(testChainID, bondTx).(account.SignatureEd25519)
- bondTx.Inputs[0].Signature = acc0 acm.ChainSign(testChainID, bondTx)
-
- // Make complete block and blockParts
- block0 := makeBlock(t, s0, nil, []txs.Tx{bondTx})
- block0Parts := block0.MakePartSet()
-
- // Sanity check
- if s0.BondedValidators.Size() != 1 {
- t.Error("Expected there to be 1 validators before bondTx")
- }
-
- // Now append the block to s0.
- err := ExecBlock(s0, block0, block0Parts.Header())
- if err != nil {
- t.Error("Error appending initial block:", err)
- }
-
- // Must save before further modification
- s0.Save()
-
- // Test new validator set
- if s0.BondedValidators.Size() != 2 {
- t.Error("Expected there to be 2 validators after bondTx")
- }
-
- // The validation for the next block should only require 1 signature
- // (the new validator wasn't active for block0)
- precommit0 := &txs.Vote{
- Height: 1,
- Round: 0,
- Type: txs.VoteTypePrecommit,
- BlockHash: block0.Hash(),
- BlockPartsHeader: block0Parts.Header(),
- }
- privValidators[0].SignVote(testChainID, precommit0)
-
- block1 := makeBlock(t, s0,
- &txs.Validation{
- Precommits: []*txs.Vote{
- precommit0,
- },
- }, nil,
- )
- block1Parts := block1.MakePartSet()
- err = ExecBlock(s0, block1, block1Parts.Header())
- if err != nil {
- t.Error("Error appending secondary block:", err)
- }
}
-*/
diff --git a/execution/transactor.go b/execution/transactor.go
index e527fe5fd227342176a32a71e8ebc8a050130098..f54cd02f60a3f56029e994ab5f699032cae206dc 100644
--- a/execution/transactor.go
+++ b/execution/transactor.go
@@ -60,7 +60,7 @@ type Transactor interface {
type transactor struct {
txMtx sync.Mutex
blockchain blockchain.Blockchain
- state acm.StateReader
+ state acm.StateIterable
eventEmitter event.Emitter
broadcastTxAsync func(tx txs.Tx, callback func(res *abci_types.Response)) error
logger logging_types.InfoTraceLogger
@@ -68,7 +68,7 @@ type transactor struct {
var _ Transactor = &transactor{}
-func NewTransactor(blockchain blockchain.Blockchain, state acm.StateReader, eventEmitter event.Emitter,
+func NewTransactor(blockchain blockchain.Blockchain, state acm.StateIterable, eventEmitter event.Emitter,
broadcastTxAsync func(tx txs.Tx, callback func(res *abci_types.Response)) error,
logger logging_types.InfoTraceLogger) *transactor {
@@ -98,7 +98,7 @@ func (trans *transactor) Call(fromAddress, toAddress acm.Address, data []byte) (
return nil, fmt.Errorf("account %s does not exist", toAddress)
}
caller := acm.ConcreteAccount{Address: fromAddress}.MutableAccount()
- txCache := NewTxCache(trans.state)
+ txCache := acm.NewStateCache(trans.state)
params := vmParams(trans.blockchain)
vmach := evm.NewVM(txCache, evm.DefaultDynamicMemoryProvider, params, caller.Address(), nil,
@@ -120,7 +120,7 @@ func (trans *transactor) CallCode(fromAddress acm.Address, code, data []byte) (*
// This was being run against CheckTx cache, need to understand the reasoning
callee := acm.ConcreteAccount{Address: fromAddress}.MutableAccount()
caller := acm.ConcreteAccount{Address: fromAddress}.MutableAccount()
- txCache := NewTxCache(trans.state)
+ txCache := acm.NewStateCache(trans.state)
params := vmParams(trans.blockchain)
vmach := evm.NewVM(txCache, evm.DefaultDynamicMemoryProvider, params, caller.Address(), nil,
@@ -140,6 +140,9 @@ func (trans *transactor) BroadcastTxAsync(tx txs.Tx, callback func(res *abci_typ
// Broadcast a transaction.
func (trans *transactor) BroadcastTx(tx txs.Tx) (*txs.Receipt, error) {
+ trans.logger.Trace("method", "BroadcastTx",
+ "tx_hash", tx.Hash(trans.blockchain.ChainID()),
+ "tx", tx.String())
responseCh := make(chan *abci_types.Response, 1)
err := trans.BroadcastTxAsync(tx, func(res *abci_types.Response) {
responseCh <- res
diff --git a/execution/tx_cache.go b/execution/tx_cache.go
deleted file mode 100644
index 4dc56485f739954c5ab9f5c7e0f70c210c66a826..0000000000000000000000000000000000000000
--- a/execution/tx_cache.go
+++ /dev/null
@@ -1,128 +0,0 @@
-// Copyright 2017 Monax Industries Limited
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package execution
-
-import (
- "fmt"
-
- acm "github.com/hyperledger/burrow/account"
- "github.com/hyperledger/burrow/binary"
-)
-
-type TxCache struct {
- backend acm.StateReader
- accounts map[acm.Address]vmAccountInfo
- storages map[binary.Tuple256]binary.Word256
-}
-
-var _ acm.StateWriter = &TxCache{}
-
-func NewTxCache(backend acm.StateReader) *TxCache {
- return &TxCache{
- backend: backend,
- accounts: make(map[acm.Address]vmAccountInfo),
- storages: make(map[binary.Tuple256]binary.Word256),
- }
-}
-
-//-------------------------------------
-// TxCache.account
-
-func (cache *TxCache) GetAccount(addr acm.Address) (acm.Account, error) {
- acc, removed := cache.accounts[addr].unpack()
- if removed {
- return nil, nil
- } else if acc == nil {
- return cache.backend.GetAccount(addr)
- }
- return acc, nil
-}
-
-func (cache *TxCache) UpdateAccount(acc acm.Account) error {
- _, removed := cache.accounts[acc.Address()].unpack()
- if removed {
- return fmt.Errorf("UpdateAccount on a removed account %s", acc.Address())
- }
- cache.accounts[acc.Address()] = vmAccountInfo{acc, false}
- return nil
-}
-
-func (cache *TxCache) RemoveAccount(addr acm.Address) error {
- acc, removed := cache.accounts[addr].unpack()
- if removed {
- fmt.Errorf("RemoveAccount on a removed account %s", addr)
- }
- cache.accounts[addr] = vmAccountInfo{acc, true}
- return nil
-}
-
-// TxCache.account
-//-------------------------------------
-// TxCache.storage
-
-func (cache *TxCache) GetStorage(addr acm.Address, key binary.Word256) (binary.Word256, error) {
- // Check cache
- value, ok := cache.storages[binary.Tuple256{First: addr.Word256(), Second: key}]
- if ok {
- return value, nil
- }
-
- // Load from backend
- return cache.backend.GetStorage(addr, key)
-}
-
-// NOTE: Set value to zero to removed from the trie.
-func (cache *TxCache) SetStorage(addr acm.Address, key binary.Word256, value binary.Word256) error {
- _, removed := cache.accounts[addr].unpack()
- if removed {
- fmt.Errorf("SetStorage on a removed account %s", addr)
- }
- cache.storages[binary.Tuple256{First: addr.Word256(), Second: key}] = value
- return nil
-}
-
-// TxCache.storage
-//-------------------------------------
-
-// These updates do not have to be in deterministic order,
-// the backend is responsible for ordering updates.
-func (cache *TxCache) Sync(backend acm.StateWriter) {
- // Remove or update storage
- for addrKey, value := range cache.storages {
- addrWord256, key := binary.Tuple256Split(addrKey)
- backend.SetStorage(acm.AddressFromWord256(addrWord256), key, value)
- }
-
- // Remove or update accounts
- for addr, accInfo := range cache.accounts {
- acc, removed := accInfo.unpack()
- if removed {
- backend.RemoveAccount(addr)
- } else {
- backend.UpdateAccount(acc)
- }
- }
-}
-
-//-----------------------------------------------------------------------------
-
-type vmAccountInfo struct {
- account acm.Account
- removed bool
-}
-
-func (accInfo vmAccountInfo) unpack() (acm.Account, bool) {
- return accInfo.account, accInfo.removed
-}
diff --git a/genesis/deterministic_genesis.go b/genesis/deterministic_genesis.go
index d511cc20ec85e134932f73268e1c12896632e3b0..402a588bdc2afb617404b82469b46c159f3d820a 100644
--- a/genesis/deterministic_genesis.go
+++ b/genesis/deterministic_genesis.go
@@ -21,7 +21,7 @@ func NewDeterministicGenesis(seed int64) *deterministicGenesis {
}
func (dg *deterministicGenesis) GenesisDoc(numAccounts int, randBalance bool, minBalance uint64, numValidators int,
- randBonded bool, minBonded int64) (*GenesisDoc, []acm.PrivateAccount) {
+ randBonded bool, minBonded int64) (*GenesisDoc, []acm.PrivateAccount, []acm.PrivateAccount) {
accounts := make([]Account, numAccounts)
privAccounts := make([]acm.PrivateAccount, numAccounts)
@@ -38,8 +38,10 @@ func (dg *deterministicGenesis) GenesisDoc(numAccounts int, randBalance bool, mi
privAccounts[i] = privAccount
}
validators := make([]Validator, numValidators)
+ privValidators := make([]acm.PrivateAccount, numValidators)
for i := 0; i < numValidators; i++ {
validator := acm.GeneratePrivateAccountFromSecret(fmt.Sprintf("val_%v", i))
+ privValidators[i] = validator
validators[i] = Validator{
BasicAccount: BasicAccount{
Address: validator.Address(),
@@ -59,7 +61,7 @@ func (dg *deterministicGenesis) GenesisDoc(numAccounts int, randBalance bool, mi
GenesisTime: time.Unix(1506172037, 0),
Accounts: accounts,
Validators: validators,
- }, privAccounts
+ }, privAccounts, privValidators
}
diff --git a/logging/loggers/info_trace_logger.go b/logging/loggers/info_trace_logger.go
index 7e3923e0c7a09c242e8e6e9857402c6a6e726ce4..df51014787d13d90075847869a52f0a01b7d9955 100644
--- a/logging/loggers/info_trace_logger.go
+++ b/logging/loggers/info_trace_logger.go
@@ -97,6 +97,7 @@ func (l *infoTraceLogger) Log(keyvals ...interface{}) error {
// Wrap the output loggers with a a set of standard transforms, a non-blocking
// ChannelLogger and an outer context
func wrapOutputLogger(outputLogger kitlog.Logger) (kitlog.Logger, channels.Channel) {
- return NonBlockingLogger(VectorValuedLogger(SortLogger(BurrowFormatLogger(outputLogger),
- structure.ChannelKey, structure.MessageKey, structure.TimeKey, structure.ComponentKey)))
+ //return outputLogger, channels.NewDeadChannel()
+ return VectorValuedLogger(SortLogger(BurrowFormatLogger(outputLogger),
+ structure.ChannelKey, structure.MessageKey, structure.TimeKey, structure.ComponentKey)), channels.NewDeadChannel()
}
diff --git a/server/server.go b/process/process.go
similarity index 78%
rename from server/server.go
rename to process/process.go
index 08a70efb70256fed69584a00d9257161ccb00273..960f5b7ef3579ef2e13250cade835a234c220363 100644
--- a/server/server.go
+++ b/process/process.go
@@ -1,4 +1,4 @@
-package server
+package process
import (
"context"
@@ -7,7 +7,7 @@ import (
)
// Copies the signature from http.Server's graceful shutdown method
-type Server interface {
+type Process interface {
Shutdown(context.Context) error
}
@@ -19,7 +19,7 @@ func (sf ShutdownFunc) Shutdown(ctx context.Context) error {
type Launcher struct {
Name string
- Launch func() (Server, error)
+ Launch func() (Process, error)
}
type listenersServer struct {
@@ -27,8 +27,8 @@ type listenersServer struct {
listeners map[net.Listener]struct{}
}
-// Providers a Server implementation from Listeners that are closed on shutdown
-func FromListeners(listeners ...net.Listener) Server {
+// Providers a Process implementation from Listeners that are closed on shutdown
+func FromListeners(listeners ...net.Listener) Process {
lns := make(map[net.Listener]struct{}, len(listeners))
for _, l := range listeners {
lns[l] = struct{}{}
diff --git a/rpc/service.go b/rpc/service.go
index 1c127df665d2e5e49834eb8d89790ad0113bf679..c91e7645ce90ec09fad5236c4267f5b977a14a04 100644
--- a/rpc/service.go
+++ b/rpc/service.go
@@ -243,6 +243,9 @@ func (s *service) GetAccount(address acm.Address) (*ResultGetAccount, error) {
if err != nil {
return nil, err
}
+ s.logger.Trace("method", "GetAccount",
+ "address", address,
+ "sequence", acc.Sequence())
return &ResultGetAccount{Account: acm.AsConcreteAccount(acc)}, nil
}
@@ -301,7 +304,10 @@ func (s *service) DumpStorage(address acm.Address) (*ResultDumpStorage, error) {
// Name registry
func (s *service) GetName(name string) (*ResultGetName, error) {
- entry := s.nameReg.GetNameRegEntry(name)
+ entry, err := s.nameReg.GetNameRegEntry(name)
+ if err != nil {
+ return nil, err
+ }
if entry == nil {
return nil, fmt.Errorf("name %s not found", name)
}
diff --git a/rpc/tm/integration/client_test.go b/rpc/tm/integration/client_test.go
index bf62e6c7be72403145be18d2667ffafea5a69af9..a827524f9de0ac13e438dd2f8d76ad002fda442f 100644
--- a/rpc/tm/integration/client_test.go
+++ b/rpc/tm/integration/client_test.go
@@ -55,7 +55,7 @@ func TestBroadcastTx(t *testing.T) {
amt := hashString(clientName) % 1000
toAddr := privateAccounts[1].Address()
tx := makeDefaultSendTxSigned(t, client, toAddr, amt)
- receipt, err := broadcastTxAndWaitForBlock(t, client, wsc, tx)
+ receipt, err := broadcastTxAndWait(t, client, wsc, tx)
require.NoError(t, err)
assert.False(t, receipt.CreatesContract, "This tx should not create a contract")
assert.NotEmpty(t, receipt.TxHash, "Failed to compute tx hash")
@@ -102,7 +102,7 @@ func TestGetStorage(t *testing.T) {
code := []byte{0x60, 0x5, 0x60, 0x1, 0x55}
// Call with nil address will create a contract
tx := makeDefaultCallTx(t, client, nil, code, amt, gasLim, fee)
- receipt, err := broadcastTxAndWaitForBlock(t, client, wsc, tx)
+ receipt, err := broadcastTxAndWait(t, client, wsc, tx)
assert.NoError(t, err)
assert.Equal(t, true, receipt.CreatesContract, "This transaction should"+
" create a contract")
@@ -156,7 +156,7 @@ func TestCallContract(t *testing.T) {
amt, gasLim, fee := uint64(6969), uint64(1000), uint64(1000)
code, _, _ := simpleContract()
tx := makeDefaultCallTx(t, client, nil, code, amt, gasLim, fee)
- receipt, err := broadcastTxAndWaitForBlock(t, client, wsc, tx)
+ receipt, err := broadcastTxAndWait(t, client, wsc, tx)
assert.NoError(t, err)
if err != nil {
t.Fatalf("Problem broadcasting transaction: %v", err)
@@ -197,7 +197,7 @@ func TestNameReg(t *testing.T) {
// verify the name by both using the event and by checking get_name
subscribeAndWaitForNext(t, wsc, exe_events.EventStringNameReg(name),
func() {
- broadcastTxAndWaitForBlock(t, client, wsc, tx)
+ broadcastTxAndWait(t, client, wsc, tx)
},
func(eventID string, resultEvent *rpc.ResultEvent) (bool, error) {
@@ -224,7 +224,7 @@ func TestNameReg(t *testing.T) {
amt = fee + numDesiredBlocks*txs.NameByteCostMultiplier*
txs.NameBlockCostMultiplier*txs.NameBaseCost(name, updatedData)
tx = makeDefaultNameTx(t, client, name, updatedData, amt, fee)
- broadcastTxAndWaitForBlock(t, client, wsc, tx)
+ broadcastTxAndWait(t, client, wsc, tx)
entry = getNameRegEntry(t, client, name)
assert.Equal(t, updatedData, entry.Data)
@@ -234,7 +234,7 @@ func TestNameReg(t *testing.T) {
getSequence(t, client, privateAccounts[1].Address())+1)
tx.Sign(genesisDoc.ChainID(), privateAccounts[1])
- _, err := broadcastTxAndWaitForBlock(t, client, wsc, tx)
+ _, err := broadcastTxAndWait(t, client, wsc, tx)
assert.Error(t, err, "Expected error when updating someone else's unexpired"+
" name registry entry")
if err != nil {
@@ -250,7 +250,7 @@ func TestNameReg(t *testing.T) {
tx = txs.NewNameTxWithSequence(privateAccounts[1].PublicKey(), name, data2, amt, fee,
getSequence(t, client, privateAccounts[1].Address())+1)
tx.Sign(genesisDoc.ChainID(), privateAccounts[1])
- _, err = broadcastTxAndWaitForBlock(t, client, wsc, tx)
+ _, err = broadcastTxAndWait(t, client, wsc, tx)
assert.NoError(t, err, "Should be able to update a previously expired name"+
" registry entry as a different address")
entry = getNameRegEntry(t, client, name)
diff --git a/rpc/tm/integration/shared.go b/rpc/tm/integration/shared.go
index a12358f1deb0d6c04a3dd073605a09c602c7bcf4..d7ad492993dc992d02412d5b61ba299fcd514d73 100644
--- a/rpc/tm/integration/shared.go
+++ b/rpc/tm/integration/shared.go
@@ -35,6 +35,7 @@ import (
"github.com/hyperledger/burrow/core"
"github.com/hyperledger/burrow/execution"
"github.com/hyperledger/burrow/genesis"
+ "github.com/hyperledger/burrow/logging/config"
"github.com/hyperledger/burrow/logging/lifecycle"
"github.com/hyperledger/burrow/logging/loggers"
"github.com/hyperledger/burrow/permission"
@@ -55,7 +56,7 @@ const (
)
// Enable logger output during tests
-var debugLogging = false
+var debugLogging = true
// global variables for use across all tests
var (
@@ -72,7 +73,7 @@ var (
// We use this to wrap tests
func TestWrapper(runner func() int) int {
- fmt.Println("Running with integration TestWrapper (rpc/tm/client/shared.go)...")
+ fmt.Println("Running with integration TestWrapper (rpc/tm/integration/shared.go)...")
os.RemoveAll(testDir)
os.MkdirAll(testDir, 0777)
@@ -81,7 +82,27 @@ func TestWrapper(runner func() int) int {
tmConf := tm_config.DefaultConfig()
logger := loggers.NewNoopInfoTraceLogger()
if debugLogging {
- logger, _, _ = lifecycle.NewStdErrLogger()
+ var err error
+ // Change config as needed
+ logger, err = lifecycle.NewLoggerFromLoggingConfig(&config.LoggingConfig{
+ RootSink: config.Sink().
+ SetTransform(config.FilterTransform(config.IncludeWhenAnyMatches,
+ //"","",
+ "method", "GetAccount",
+ "method", "BroadcastTx",
+ "tag", "sequence",
+ "tag", "Commit",
+ "tag", "CheckTx",
+ "tag", "DeliverTx",
+ )).
+ //AddSinks(config.Sink().SetTransform(config.FilterTransform(config.ExcludeWhenAnyMatches, "run_call", "false")).
+ AddSinks(config.Sink().SetTransform(config.PruneTransform("log_channel", "trace", "scope", "returns", "run_id", "args")).
+ AddSinks(config.Sink().SetTransform(config.SortTransform("tx_hash", "time", "message", "method")).
+ SetOutput(config.StdoutOutput()))),
+ })
+ if err != nil {
+ panic(err)
+ }
}
privValidator := validator.NewPrivValidatorMemory(privateAccounts[0], privateAccounts[0])
@@ -90,7 +111,10 @@ func TestWrapper(runner func() int) int {
if err != nil {
panic(err)
}
- defer kernel.Shutdown(context.Background())
+ // Sometimes better to not shutdown as logging errors on shutdown may obscure real issue
+ defer func() {
+ //kernel.Shutdown(context.Background())
+ }()
err = kernel.Boot()
if err != nil {
@@ -165,7 +189,6 @@ func makeDefaultNameTx(t *testing.T, client tm_client.RPCClient, name, value str
// get an account's sequence number
func getSequence(t *testing.T, client tm_client.RPCClient, addr acm.Address) uint64 {
-
acc, err := tm_client.GetAccount(client, addr)
if err != nil {
t.Fatal(err)
diff --git a/rpc/tm/integration/shared_test.go b/rpc/tm/integration/shared_test.go
index d126df307396c491f6fc2c5f2528c927efc8835c..9e8f1d17d1dc0d498b145a7dbe9767c6549eb643 100644
--- a/rpc/tm/integration/shared_test.go
+++ b/rpc/tm/integration/shared_test.go
@@ -20,6 +20,7 @@ package integration
import (
"os"
"testing"
+ "time"
)
// Needs to be in a _test.go file to be picked up
@@ -28,5 +29,6 @@ func TestMain(m *testing.M) {
return m.Run()
})
+ time.Sleep(3 * time.Second)
os.Exit(returnValue)
}
diff --git a/rpc/tm/integration/websocket_client_test.go b/rpc/tm/integration/websocket_client_test.go
index e13e817efc78206fbc27b08ff51324b5fd3c5877..bc6da482db85d6cb4b5b264bca60ac37ae28f30d 100644
--- a/rpc/tm/integration/websocket_client_test.go
+++ b/rpc/tm/integration/websocket_client_test.go
@@ -28,7 +28,6 @@ import (
evm_events "github.com/hyperledger/burrow/execution/evm/events"
"github.com/hyperledger/burrow/rpc"
tm_client "github.com/hyperledger/burrow/rpc/tm/client"
- "github.com/hyperledger/burrow/txs"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
tm_types "github.com/tendermint/tendermint/types"
@@ -154,36 +153,35 @@ func TestWSCallWait(t *testing.T) {
t.Skip("skipping test in short mode.")
}
wsc := newWSClient()
- eid1 := exe_events.EventStringAccountInput(privateAccounts[0].Address())
- subId1 := subscribeAndGetSubscriptionId(t, wsc, eid1)
- defer func() {
+ defer stopWSClient(wsc)
+ // Mini soak test
+ for i := 0; i < 20; i++ {
+ amt, gasLim, fee := uint64(10000), uint64(1000), uint64(1000)
+ code, returnCode, returnVal := simpleContract()
+ var contractAddr acm.Address
+ eid1 := exe_events.EventStringAccountInput(privateAccounts[0].Address())
+ subId1 := subscribeAndGetSubscriptionId(t, wsc, eid1)
+ // wait for the contract to be created
+ waitForEvent(t, wsc, eid1, func() {
+ tx := makeDefaultCallTx(t, jsonRpcClient, nil, code, amt, gasLim, fee)
+ receipt := broadcastTx(t, jsonRpcClient, tx)
+ contractAddr = receipt.ContractAddress
+ }, unmarshalValidateTx(amt, returnCode))
unsubscribe(t, wsc, subId1)
- stopWSClient(wsc)
- }()
- amt, gasLim, fee := uint64(10000), uint64(1000), uint64(1000)
- code, returnCode, returnVal := simpleContract()
- var contractAddr acm.Address
- // wait for the contract to be created
- waitForEvent(t, wsc, eid1, func() {
- tx := makeDefaultCallTx(t, jsonRpcClient, nil, code, amt, gasLim, fee)
- receipt := broadcastTx(t, jsonRpcClient, tx)
- contractAddr = receipt.ContractAddress
- }, unmarshalValidateTx(amt, returnCode))
- // susbscribe to the new contract
- amt = uint64(10001)
- eid2 := exe_events.EventStringAccountOutput(contractAddr)
- subId2 := subscribeAndGetSubscriptionId(t, wsc, eid2)
- defer func() {
+ // susbscribe to the new contract
+ amt = uint64(10001)
+ eid2 := exe_events.EventStringAccountOutput(contractAddr)
+ subId2 := subscribeAndGetSubscriptionId(t, wsc, eid2)
+ // get the return value from a call
+ data := []byte{0x1}
+ waitForEvent(t, wsc, eid2, func() {
+ tx := makeDefaultCallTx(t, jsonRpcClient, &contractAddr, data, amt, gasLim, fee)
+ receipt := broadcastTx(t, jsonRpcClient, tx)
+ contractAddr = receipt.ContractAddress
+ }, unmarshalValidateTx(amt, returnVal))
unsubscribe(t, wsc, subId2)
- }()
- // get the return value from a call
- data := []byte{0x1}
- waitForEvent(t, wsc, eid2, func() {
- tx := makeDefaultCallTx(t, jsonRpcClient, &contractAddr, data, amt, gasLim, fee)
- receipt := broadcastTx(t, jsonRpcClient, tx)
- contractAddr = receipt.ContractAddress
- }, unmarshalValidateTx(amt, returnVal))
+ }
}
// create a contract and send it a msg without waiting. wait for contract event
@@ -198,7 +196,7 @@ func TestWSCallNoWait(t *testing.T) {
code, _, returnVal := simpleContract()
tx := makeDefaultCallTx(t, jsonRpcClient, nil, code, amt, gasLim, fee)
- receipt, err := broadcastTxAndWaitForBlock(t, jsonRpcClient, wsc, tx)
+ receipt, err := broadcastTxAndWait(t, jsonRpcClient, wsc, tx)
require.NoError(t, err)
contractAddr := receipt.ContractAddress
@@ -224,11 +222,11 @@ func TestWSCallCall(t *testing.T) {
defer stopWSClient(wsc)
amt, gasLim, fee := uint64(10000), uint64(1000), uint64(1000)
code, _, returnVal := simpleContract()
- txid := new([]byte)
+ TxHash := new([]byte)
// deploy the two contracts
tx := makeDefaultCallTx(t, jsonRpcClient, nil, code, amt, gasLim, fee)
- receipt, err := broadcastTxAndWaitForBlock(t, jsonRpcClient, wsc, tx)
+ receipt, err := broadcastTxAndWait(t, jsonRpcClient, wsc, tx)
require.NoError(t, err)
contractAddr1 := receipt.ContractAddress
@@ -257,10 +255,10 @@ func TestWSCallCall(t *testing.T) {
func() {
tx := makeDefaultCallTx(t, jsonRpcClient, &contractAddr2, nil, amt, gasLim, fee)
broadcastTx(t, jsonRpcClient, tx)
- *txid = txs.TxHash(genesisDoc.ChainID(), tx)
+ *TxHash = tx.Hash(genesisDoc.ChainID())
},
// Event checker
- unmarshalValidateCall(privateAccounts[0].Address(), returnVal, txid))
+ unmarshalValidateCall(privateAccounts[0].Address(), returnVal, TxHash))
}
func TestSubscribe(t *testing.T) {
diff --git a/rpc/tm/integration/websocket_helpers.go b/rpc/tm/integration/websocket_helpers.go
index a69cf9a675daea5ff4d2ef69a58f77f9c6d13095..ec1c7ff2cfc22e50aa1b6c4840697fe0e72a316c 100644
--- a/rpc/tm/integration/websocket_helpers.go
+++ b/rpc/tm/integration/websocket_helpers.go
@@ -25,6 +25,7 @@ import (
"time"
acm "github.com/hyperledger/burrow/account"
+ "github.com/hyperledger/burrow/execution/events"
"github.com/hyperledger/burrow/rpc"
tm_client "github.com/hyperledger/burrow/rpc/tm/client"
"github.com/hyperledger/burrow/txs"
@@ -94,14 +95,23 @@ func unsubscribe(t *testing.T, wsc *rpcclient.WSClient, subscriptionId string) {
}
// broadcast transaction and wait for new block
-func broadcastTxAndWaitForBlock(t *testing.T, client tm_client.RPCClient, wsc *rpcclient.WSClient,
+func broadcastTxAndWait(t *testing.T, client tm_client.RPCClient, wsc *rpcclient.WSClient,
tx txs.Tx) (*txs.Receipt, error) {
+ inputs := tx.GetInputs()
+ if len(inputs) == 0 {
+ t.Fatalf("cannot broadcastAndWait fot Tx with no inputs")
+ }
+ address := inputs[0].Address
+
var rec *txs.Receipt
var err error
- runThenWaitForBlock(t, wsc, nextBlockPredicateFn(),
+
+ subscribeAndWaitForNext(t, wsc, events.EventStringAccountInput(address),
func() {
rec, err = tm_client.BroadcastTx(client, tx)
+ }, func(eventID string, resultEvent *rpc.ResultEvent) (bool, error) {
+ return true, nil
})
return rec, err
}
@@ -159,7 +169,6 @@ func subscribeAndWaitForNext(t *testing.T, wsc *rpcclient.WSClient, event string
// waitForEvent will fail the test.
func waitForEvent(t *testing.T, wsc *rpcclient.WSClient, eventID string, runner func(),
checker resultEventChecker) waitForEventResult {
-
// go routine to wait for websocket msg
eventsCh := make(chan *rpc.ResultEvent)
shutdownEventsCh := make(chan bool, 1)
diff --git a/txs/go_wire_codec.go b/txs/go_wire_codec.go
index ebedfcf7bc1d699d4d72a8238f493ccc4eb47de6..320c1f5e956a246fadf16937a3cdedb5142bec6c 100644
--- a/txs/go_wire_codec.go
+++ b/txs/go_wire_codec.go
@@ -31,7 +31,8 @@ func (gwc *goWireCodec) EncodeTx(tx Tx) ([]byte, error) {
if err != nil {
return nil, err
}
- return buf.Bytes(), nil
+ // Tendermint mempool exhibits odd concurrency issues when using a mutable buffer
+ return copyBuffer(buf)
}
// panic on err
@@ -51,3 +52,12 @@ func (gwc *goWireCodec) recycle(buf *bytes.Buffer) {
buf.Reset()
gwc.bufferPool.Put(buf)
}
+
+func copyBuffer(buf *bytes.Buffer) ([]byte, error) {
+ bs := make([]byte, buf.Len())
+ _, err := buf.Read(bs)
+ if err != nil {
+ return nil, err
+ }
+ return bs, nil
+}
diff --git a/txs/tx.go b/txs/tx.go
index 7838e86646d61803a7a2b0ab11df6b028c79305a..1133e948718f5bcc0188c1e6127fa12f90f2ce61 100644
--- a/txs/tx.go
+++ b/txs/tx.go
@@ -102,6 +102,8 @@ type (
Tx interface {
WriteSignBytes(chainID string, w io.Writer, n *int, err *error)
String() string
+ GetInputs() []TxInput
+ Hash(chainID string) []byte
}
Wrapper struct {
@@ -116,9 +118,17 @@ type (
DecodeTx(txBytes []byte) (Tx, error)
}
- SendTx struct {
- Inputs []*TxInput
- Outputs []*TxOutput
+ TxInput struct {
+ Address acm.Address
+ Amount uint64
+ Sequence uint64
+ Signature acm.Signature
+ PublicKey acm.PublicKey
+ }
+
+ TxOutput struct {
+ Address acm.Address
+ Amount uint64
}
// BroadcastTx or Transact
@@ -128,11 +138,20 @@ type (
ContractAddress acm.Address
}
+ //-------------------
+ // Transaction Types
+ SendTx struct {
+ Inputs []*TxInput
+ Outputs []*TxOutput
+ txHashMemoizer
+ }
+
NameTx struct {
Input *TxInput
Name string
Data string
Fee uint64
+ txHashMemoizer
}
CallTx struct {
@@ -142,19 +161,36 @@ type (
GasLimit uint64
Fee uint64
Data []byte
+ txHashMemoizer
}
- TxInput struct {
+ PermissionsTx struct {
+ Input *TxInput
+ PermArgs ptypes.PermArgs
+ txHashMemoizer
+ }
+
+ // Out of service
+ BondTx struct {
+ PubKey acm.PublicKey
+ Signature acm.Signature
+ Inputs []*TxInput
+ UnbondTo []*TxOutput
+ txHashMemoizer
+ }
+
+ UnbondTx struct {
Address acm.Address
- Amount uint64
- Sequence uint64
+ Height int
Signature acm.Signature
- PublicKey acm.PublicKey
+ txHashMemoizer
}
- TxOutput struct {
- Address acm.Address
- Amount uint64
+ RebondTx struct {
+ Address acm.Address
+ Height int
+ Signature acm.Signature
+ txHashMemoizer
}
)
@@ -249,10 +285,18 @@ func (tx *SendTx) WriteSignBytes(chainID string, w io.Writer, n *int, err *error
wire.WriteTo([]byte(`]}]}`), w, n, err)
}
+func (tx *SendTx) GetInputs() []TxInput {
+ return copyInputs(tx.Inputs)
+}
+
func (tx *SendTx) String() string {
return fmt.Sprintf("SendTx{%v -> %v}", tx.Inputs, tx.Outputs)
}
+func (tx *SendTx) Hash(chainID string) []byte {
+ return tx.txHashMemoizer.hash(chainID, tx)
+}
+
//-----------------------------------------------------------------------------
func (tx *CallTx) WriteSignBytes(chainID string, w io.Writer, n *int, err *error) {
@@ -263,10 +307,18 @@ func (tx *CallTx) WriteSignBytes(chainID string, w io.Writer, n *int, err *error
wire.WriteTo([]byte(`}]}`), w, n, err)
}
+func (tx *CallTx) GetInputs() []TxInput {
+ return []TxInput{*tx.Input}
+}
+
func (tx *CallTx) String() string {
return fmt.Sprintf("CallTx{%v -> %s: %X}", tx.Input, tx.Address, tx.Data)
}
+func (tx *CallTx) Hash(chainID string) []byte {
+ return tx.txHashMemoizer.hash(chainID, tx)
+}
+
//-----------------------------------------------------------------------------
func (tx *NameTx) WriteSignBytes(chainID string, w io.Writer, n *int, err *error) {
@@ -278,6 +330,10 @@ func (tx *NameTx) WriteSignBytes(chainID string, w io.Writer, n *int, err *error
wire.WriteTo([]byte(`}]}`), w, n, err)
}
+func (tx *NameTx) GetInputs() []TxInput {
+ return []TxInput{*tx.Input}
+}
+
func (tx *NameTx) ValidateStrings() error {
if len(tx.Name) == 0 {
return ErrTxInvalidString{"Name must not be empty"}
@@ -304,15 +360,12 @@ func (tx *NameTx) String() string {
return fmt.Sprintf("NameTx{%v -> %s: %s}", tx.Input, tx.Name, tx.Data)
}
-//-----------------------------------------------------------------------------
-
-type BondTx struct {
- PubKey acm.PublicKey
- Signature acm.Signature
- Inputs []*TxInput
- UnbondTo []*TxOutput
+func (tx *NameTx) Hash(chainID string) []byte {
+ return tx.txHashMemoizer.hash(chainID, tx)
}
+//-----------------------------------------------------------------------------
+
func (tx *BondTx) WriteSignBytes(chainID string, w io.Writer, n *int, err *error) {
wire.WriteTo([]byte(fmt.Sprintf(`{"chain_id":%s`, jsonEscape(chainID))), w, n, err)
wire.WriteTo([]byte(fmt.Sprintf(`,"tx":[%v,{"inputs":[`, TxTypeBond)), w, n, err)
@@ -334,51 +387,58 @@ func (tx *BondTx) WriteSignBytes(chainID string, w io.Writer, n *int, err *error
wire.WriteTo([]byte(`]}]}`), w, n, err)
}
+func (tx *BondTx) GetInputs() []TxInput {
+ return copyInputs(tx.Inputs)
+}
+
func (tx *BondTx) String() string {
return fmt.Sprintf("BondTx{%v: %v -> %v}", tx.PubKey, tx.Inputs, tx.UnbondTo)
}
-//-----------------------------------------------------------------------------
-
-type UnbondTx struct {
- Address acm.Address
- Height int
- Signature acm.Signature
+func (tx *BondTx) Hash(chainID string) []byte {
+ return tx.txHashMemoizer.hash(chainID, tx)
}
+//-----------------------------------------------------------------------------
+
func (tx *UnbondTx) WriteSignBytes(chainID string, w io.Writer, n *int, err *error) {
wire.WriteTo([]byte(fmt.Sprintf(`{"chain_id":%s`, jsonEscape(chainID))), w, n, err)
wire.WriteTo([]byte(fmt.Sprintf(`,"tx":[%v,{"address":"%s","height":%v}]}`, TxTypeUnbond, tx.Address, tx.Height)), w, n, err)
}
+func (tx *UnbondTx) GetInputs() []TxInput {
+ return nil
+}
+
func (tx *UnbondTx) String() string {
return fmt.Sprintf("UnbondTx{%s,%v,%v}", tx.Address, tx.Height, tx.Signature)
}
-//-----------------------------------------------------------------------------
-
-type RebondTx struct {
- Address acm.Address
- Height int
- Signature acm.Signature
+func (tx *UnbondTx) Hash(chainID string) []byte {
+ return tx.txHashMemoizer.hash(chainID, tx)
}
+//-----------------------------------------------------------------------------
+
func (tx *RebondTx) WriteSignBytes(chainID string, w io.Writer, n *int, err *error) {
wire.WriteTo([]byte(fmt.Sprintf(`{"chain_id":%s`, jsonEscape(chainID))), w, n, err)
wire.WriteTo([]byte(fmt.Sprintf(`,"tx":[%v,{"address":"%s","height":%v}]}`, TxTypeRebond, tx.Address, tx.Height)), w, n, err)
}
+func (tx *RebondTx) GetInputs() []TxInput {
+ return nil
+}
+
func (tx *RebondTx) String() string {
return fmt.Sprintf("RebondTx{%s,%v,%v}", tx.Address, tx.Height, tx.Signature)
}
-//-----------------------------------------------------------------------------
-
-type PermissionsTx struct {
- Input *TxInput
- PermArgs ptypes.PermArgs
+func (tx *RebondTx) Hash(chainID string) []byte {
+ return tx.txHashMemoizer.hash(chainID, tx)
}
+//-----------------------------------------------------------------------------
+
func (tx *PermissionsTx) WriteSignBytes(chainID string, w io.Writer, n *int, err *error) {
wire.WriteTo([]byte(fmt.Sprintf(`{"chain_id":%s`, jsonEscape(chainID))), w, n, err)
wire.WriteTo([]byte(fmt.Sprintf(`,"tx":[%v,{"args":"`, TxTypePermissions)), w, n, err)
@@ -388,12 +448,34 @@ func (tx *PermissionsTx) WriteSignBytes(chainID string, w io.Writer, n *int, err
wire.WriteTo([]byte(`}]}`), w, n, err)
}
+func (tx *PermissionsTx) GetInputs() []TxInput {
+ return []TxInput{*tx.Input}
+}
+
func (tx *PermissionsTx) String() string {
return fmt.Sprintf("PermissionsTx{%v -> %v}", tx.Input, tx.PermArgs)
}
+func (tx *PermissionsTx) Hash(chainID string) []byte {
+ return tx.txHashMemoizer.hash(chainID, tx)
+}
+
//-----------------------------------------------------------------------------
+// Avoid re-hashing the same in-memory Tx
+type txHashMemoizer struct {
+ txHashBytes []byte
+ chainID string
+}
+
+func (thm *txHashMemoizer) hash(chainID string, tx Tx) []byte {
+ if thm.txHashBytes == nil || thm.chainID != chainID {
+ thm.chainID = chainID
+ thm.txHashBytes = TxHash(chainID, tx)
+ }
+ return thm.txHashBytes
+}
+
func TxHash(chainID string, tx Tx) []byte {
signBytes := acm.SignBytes(chainID, tx)
hasher := ripemd160.New()
@@ -402,11 +484,9 @@ func TxHash(chainID string, tx Tx) []byte {
return hasher.Sum(nil)
}
-//-----------------------------------------------------------------------------
-
func GenerateReceipt(chainId string, tx Tx) Receipt {
receipt := Receipt{
- TxHash: TxHash(chainId, tx),
+ TxHash: tx.Hash(chainId),
}
if callTx, ok := tx.(*CallTx); ok {
receipt.CreatesContract = callTx.Address == nil
@@ -421,6 +501,14 @@ func GenerateReceipt(chainId string, tx Tx) Receipt {
//--------------------------------------------------------------------------------
+func copyInputs(inputs []*TxInput) []TxInput {
+ inputsCopy := make([]TxInput, len(inputs))
+ for i, input := range inputs {
+ inputsCopy[i] = *input
+ }
+ return inputsCopy
+}
+
// Contract: This function is deterministic and completely reversible.
func jsonEscape(str string) string {
// TODO: escape without panic
diff --git a/txs/tx_test.go b/txs/tx_test.go
index 7ec8f44004742ab8bf7c63bd2a278d44877c88f0..3a10bc394cd5b5f1ffb5382a8b8ccb53c9fe1b27 100644
--- a/txs/tx_test.go
+++ b/txs/tx_test.go
@@ -237,34 +237,13 @@ func testTxMarshalJSON(t *testing.T, tx Tx) {
assert.Equal(t, string(bs), string(bsOut))
}
-/*
-func TestDupeoutTxSignable(t *testing.T) {
- privAcc := acm.GeneratePrivateAccount()
- partSetHeader := types.PartSetHeader{Total: 10, Hash: makeAddress("partsethash")}
- voteA := &types.Vote{
- Height: 10,
- Round: 2,
- Type: types.VoteTypePrevote,
- BlockHash: makeAddress("myblockhash"),
- BlockPartsHeader: partSetHeader,
- }
- sig := privAcc acm.ChainSign(chainID, voteA)
- voteA.Signature = sig.(crypto.SignatureEd25519)
- voteB := voteA.Copy()
- voteB.BlockHash = makeAddress("myotherblockhash")
- sig = privAcc acm.ChainSign(chainID, voteB)
- voteB.Signature = sig.(crypto.SignatureEd25519)
-
- dupeoutTx := &DupeoutTx{
- Address: makeAddress("address1"),
- VoteA: *voteA,
- VoteB: *voteB,
- }
- signBytes := acm.SignBytes(chainID, dupeoutTx)
- signStr := string(signBytes)
- expected := fmt.Sprintf(`{"chain_id":"%s","tx":[20,{"address":"%s","vote_a":%v,"vote_b":%v}]}`,
- chainID, *voteA, *voteB)
- if signStr != expected {
- t.Errorf("Got unexpected sign string for DupeoutTx")
+func TestTxHashMemoizer(t *testing.T) {
+ tx := &CallTx{
+ Input: &TxInput{
+ Sequence: 4,
+ },
}
-}*/
+ hsh := tx.Hash("foo")
+ assert.Equal(t, hsh, tx.txHashMemoizer.txHashBytes)
+ assert.Equal(t, "foo", tx.txHashMemoizer.chainID)
+}
diff --git a/vendor/github.com/tendermint/merkleeyes/LICENSE b/vendor/github.com/tendermint/merkleeyes/LICENSE
deleted file mode 100644
index be6f5f001adbcb70aa9f65bac429f38256c1a28a..0000000000000000000000000000000000000000
--- a/vendor/github.com/tendermint/merkleeyes/LICENSE
+++ /dev/null
@@ -1,193 +0,0 @@
-Tendermint MerkleEyes
-Copyright (C) 2015 Tendermint
-
-
-
- Apache License
- Version 2.0, January 2004
- https://www.apache.org/licenses/
-
- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
- 1. Definitions.
-
- "License" shall mean the terms and conditions for use, reproduction,
- and distribution as defined by Sections 1 through 9 of this document.
-
- "Licensor" shall mean the copyright owner or entity authorized by
- the copyright owner that is granting the License.
-
- "Legal Entity" shall mean the union of the acting entity and all
- other entities that control, are controlled by, or are under common
- control with that entity. For the purposes of this definition,
- "control" means (i) the power, direct or indirect, to cause the
- direction or management of such entity, whether by contract or
- otherwise, or (ii) ownership of fifty percent (50%) or more of the
- outstanding shares, or (iii) beneficial ownership of such entity.
-
- "You" (or "Your") shall mean an individual or Legal Entity
- exercising permissions granted by this License.
-
- "Source" form shall mean the preferred form for making modifications,
- including but not limited to software source code, documentation
- source, and configuration files.
-
- "Object" form shall mean any form resulting from mechanical
- transformation or translation of a Source form, including but
- not limited to compiled object code, generated documentation,
- and conversions to other media types.
-
- "Work" shall mean the work of authorship, whether in Source or
- Object form, made available under the License, as indicated by a
- copyright notice that is included in or attached to the work
- (an example is provided in the Appendix below).
-
- "Derivative Works" shall mean any work, whether in Source or Object
- form, that is based on (or derived from) the Work and for which the
- editorial revisions, annotations, elaborations, or other modifications
- represent, as a whole, an original work of authorship. For the purposes
- of this License, Derivative Works shall not include works that remain
- separable from, or merely link (or bind by name) to the interfaces of,
- the Work and Derivative Works thereof.
-
- "Contribution" shall mean any work of authorship, including
- the original version of the Work and any modifications or additions
- to that Work or Derivative Works thereof, that is intentionally
- submitted to Licensor for inclusion in the Work by the copyright owner
- or by an individual or Legal Entity authorized to submit on behalf of
- the copyright owner. For the purposes of this definition, "submitted"
- means any form of electronic, verbal, or written communication sent
- to the Licensor or its representatives, including but not limited to
- communication on electronic mailing lists, source code control systems,
- and issue tracking systems that are managed by, or on behalf of, the
- Licensor for the purpose of discussing and improving the Work, but
- excluding communication that is conspicuously marked or otherwise
- designated in writing by the copyright owner as "Not a Contribution."
-
- "Contributor" shall mean Licensor and any individual or Legal Entity
- on behalf of whom a Contribution has been received by Licensor and
- subsequently incorporated within the Work.
-
- 2. Grant of Copyright License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- copyright license to reproduce, prepare Derivative Works of,
- publicly display, publicly perform, sublicense, and distribute the
- Work and such Derivative Works in Source or Object form.
-
- 3. Grant of Patent License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- (except as stated in this section) patent license to make, have made,
- use, offer to sell, sell, import, and otherwise transfer the Work,
- where such license applies only to those patent claims licensable
- by such Contributor that are necessarily infringed by their
- Contribution(s) alone or by combination of their Contribution(s)
- with the Work to which such Contribution(s) was submitted. If You
- institute patent litigation against any entity (including a
- cross-claim or counterclaim in a lawsuit) alleging that the Work
- or a Contribution incorporated within the Work constitutes direct
- or contributory patent infringement, then any patent licenses
- granted to You under this License for that Work shall terminate
- as of the date such litigation is filed.
-
- 4. Redistribution. You may reproduce and distribute copies of the
- Work or Derivative Works thereof in any medium, with or without
- modifications, and in Source or Object form, provided that You
- meet the following conditions:
-
- (a) You must give any other recipients of the Work or
- Derivative Works a copy of this License; and
-
- (b) You must cause any modified files to carry prominent notices
- stating that You changed the files; and
-
- (c) You must retain, in the Source form of any Derivative Works
- that You distribute, all copyright, patent, trademark, and
- attribution notices from the Source form of the Work,
- excluding those notices that do not pertain to any part of
- the Derivative Works; and
-
- (d) If the Work includes a "NOTICE" text file as part of its
- distribution, then any Derivative Works that You distribute must
- include a readable copy of the attribution notices contained
- within such NOTICE file, excluding those notices that do not
- pertain to any part of the Derivative Works, in at least one
- of the following places: within a NOTICE text file distributed
- as part of the Derivative Works; within the Source form or
- documentation, if provided along with the Derivative Works; or,
- within a display generated by the Derivative Works, if and
- wherever such third-party notices normally appear. The contents
- of the NOTICE file are for informational purposes only and
- do not modify the License. You may add Your own attribution
- notices within Derivative Works that You distribute, alongside
- or as an addendum to the NOTICE text from the Work, provided
- that such additional attribution notices cannot be construed
- as modifying the License.
-
- You may add Your own copyright statement to Your modifications and
- may provide additional or different license terms and conditions
- for use, reproduction, or distribution of Your modifications, or
- for any such Derivative Works as a whole, provided Your use,
- reproduction, and distribution of the Work otherwise complies with
- the conditions stated in this License.
-
- 5. Submission of Contributions. Unless You explicitly state otherwise,
- any Contribution intentionally submitted for inclusion in the Work
- by You to the Licensor shall be under the terms and conditions of
- this License, without any additional terms or conditions.
- Notwithstanding the above, nothing herein shall supersede or modify
- the terms of any separate license agreement you may have executed
- with Licensor regarding such Contributions.
-
- 6. Trademarks. This License does not grant permission to use the trade
- names, trademarks, service marks, or product names of the Licensor,
- except as required for reasonable and customary use in describing the
- origin of the Work and reproducing the content of the NOTICE file.
-
- 7. Disclaimer of Warranty. Unless required by applicable law or
- agreed to in writing, Licensor provides the Work (and each
- Contributor provides its Contributions) on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- implied, including, without limitation, any warranties or conditions
- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
- PARTICULAR PURPOSE. You are solely responsible for determining the
- appropriateness of using or redistributing the Work and assume any
- risks associated with Your exercise of permissions under this License.
-
- 8. Limitation of Liability. In no event and under no legal theory,
- whether in tort (including negligence), contract, or otherwise,
- unless required by applicable law (such as deliberate and grossly
- negligent acts) or agreed to in writing, shall any Contributor be
- liable to You for damages, including any direct, indirect, special,
- incidental, or consequential damages of any character arising as a
- result of this License or out of the use or inability to use the
- Work (including but not limited to damages for loss of goodwill,
- work stoppage, computer failure or malfunction, or any and all
- other commercial damages or losses), even if such Contributor
- has been advised of the possibility of such damages.
-
- 9. Accepting Warranty or Additional Liability. While redistributing
- the Work or Derivative Works thereof, You may choose to offer,
- and charge a fee for, acceptance of support, warranty, indemnity,
- or other liability obligations and/or rights consistent with this
- License. However, in accepting such obligations, You may act only
- on Your own behalf and on Your sole responsibility, not on behalf
- of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability
- incurred by, or claims asserted against, such Contributor by reason
- of your accepting any such warranty or additional liability.
-
- END OF TERMS AND CONDITIONS
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- https://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
diff --git a/vendor/github.com/tendermint/merkleeyes/iavl/iavl_node.go b/vendor/github.com/tendermint/merkleeyes/iavl/iavl_node.go
deleted file mode 100644
index 8d77be68439df42ed1dc2c2fddd22be7b9b0762a..0000000000000000000000000000000000000000
--- a/vendor/github.com/tendermint/merkleeyes/iavl/iavl_node.go
+++ /dev/null
@@ -1,526 +0,0 @@
-package iavl
-
-import (
- "bytes"
- "io"
-
- "golang.org/x/crypto/ripemd160"
-
- . "github.com/tendermint/tmlibs/common"
- "github.com/tendermint/go-wire"
-)
-
-// Node
-
-type IAVLNode struct {
- key []byte
- value []byte
- height int8
- size int
- hash []byte
- leftHash []byte
- leftNode *IAVLNode
- rightHash []byte
- rightNode *IAVLNode
- persisted bool
-}
-
-func NewIAVLNode(key []byte, value []byte) *IAVLNode {
- return &IAVLNode{
- key: key,
- value: value,
- height: 0,
- size: 1,
- }
-}
-
-// NOTE: The hash is not saved or set. The caller should set the hash afterwards.
-// (Presumably the caller already has the hash)
-func MakeIAVLNode(buf []byte, t *IAVLTree) (node *IAVLNode, err error) {
- node = &IAVLNode{}
-
- // node header
- node.height = int8(buf[0])
- buf = buf[1:]
- var n int
- node.size, n, err = wire.GetVarint(buf)
- if err != nil {
- return nil, err
- }
- buf = buf[n:]
- node.key, n, err = wire.GetByteSlice(buf)
- if err != nil {
- return nil, err
- }
- buf = buf[n:]
- if node.height == 0 {
- // value
- node.value, n, err = wire.GetByteSlice(buf)
- if err != nil {
- return nil, err
- }
- buf = buf[n:]
- } else {
- // children
- leftHash, n, err := wire.GetByteSlice(buf)
- if err != nil {
- return nil, err
- }
- buf = buf[n:]
- rightHash, n, err := wire.GetByteSlice(buf)
- if err != nil {
- return nil, err
- }
- buf = buf[n:]
- node.leftHash = leftHash
- node.rightHash = rightHash
- }
- return node, nil
-}
-
-func (node *IAVLNode) _copy() *IAVLNode {
- if node.height == 0 {
- PanicSanity("Why are you copying a value node?")
- }
- return &IAVLNode{
- key: node.key,
- height: node.height,
- size: node.size,
- hash: nil, // Going to be mutated anyways.
- leftHash: node.leftHash,
- leftNode: node.leftNode,
- rightHash: node.rightHash,
- rightNode: node.rightNode,
- persisted: false, // Going to be mutated, so it can't already be persisted.
- }
-}
-
-func (node *IAVLNode) has(t *IAVLTree, key []byte) (has bool) {
- if bytes.Compare(node.key, key) == 0 {
- return true
- }
- if node.height == 0 {
- return false
- } else {
- if bytes.Compare(key, node.key) < 0 {
- return node.getLeftNode(t).has(t, key)
- } else {
- return node.getRightNode(t).has(t, key)
- }
- }
-}
-
-func (node *IAVLNode) get(t *IAVLTree, key []byte) (index int, value []byte, exists bool) {
- if node.height == 0 {
- cmp := bytes.Compare(node.key, key)
- if cmp == 0 {
- return 0, node.value, true
- } else if cmp == -1 {
- return 1, nil, false
- } else {
- return 0, nil, false
- }
- } else {
- if bytes.Compare(key, node.key) < 0 {
- return node.getLeftNode(t).get(t, key)
- } else {
- rightNode := node.getRightNode(t)
- index, value, exists = rightNode.get(t, key)
- index += node.size - rightNode.size
- return index, value, exists
- }
- }
-}
-
-func (node *IAVLNode) getByIndex(t *IAVLTree, index int) (key []byte, value []byte) {
- if node.height == 0 {
- if index == 0 {
- return node.key, node.value
- } else {
- PanicSanity("getByIndex asked for invalid index")
- return nil, nil
- }
- } else {
- // TODO: could improve this by storing the
- // sizes as well as left/right hash.
- leftNode := node.getLeftNode(t)
- if index < leftNode.size {
- return leftNode.getByIndex(t, index)
- } else {
- return node.getRightNode(t).getByIndex(t, index-leftNode.size)
- }
- }
-}
-
-// NOTE: sets hashes recursively
-func (node *IAVLNode) hashWithCount(t *IAVLTree) ([]byte, int) {
- if node.hash != nil {
- return node.hash, 0
- }
-
- hasher := ripemd160.New()
- buf := new(bytes.Buffer)
- _, hashCount, err := node.writeHashBytes(t, buf)
- if err != nil {
- PanicCrisis(err)
- }
- hasher.Write(buf.Bytes())
- node.hash = hasher.Sum(nil)
-
- return node.hash, hashCount + 1
-}
-
-// NOTE: sets hashes recursively
-func (node *IAVLNode) writeHashBytes(t *IAVLTree, w io.Writer) (n int, hashCount int, err error) {
- // height & size
- wire.WriteInt8(node.height, w, &n, &err)
- wire.WriteVarint(node.size, w, &n, &err)
- // key is not written for inner nodes, unlike writePersistBytes
-
- if node.height == 0 {
- // key & value
- wire.WriteByteSlice(node.key, w, &n, &err)
- wire.WriteByteSlice(node.value, w, &n, &err)
- } else {
- // left
- if node.leftNode != nil {
- leftHash, leftCount := node.leftNode.hashWithCount(t)
- node.leftHash = leftHash
- hashCount += leftCount
- }
- if node.leftHash == nil {
- PanicSanity("node.leftHash was nil in writeHashBytes")
- }
- wire.WriteByteSlice(node.leftHash, w, &n, &err)
- // right
- if node.rightNode != nil {
- rightHash, rightCount := node.rightNode.hashWithCount(t)
- node.rightHash = rightHash
- hashCount += rightCount
- }
- if node.rightHash == nil {
- PanicSanity("node.rightHash was nil in writeHashBytes")
- }
- wire.WriteByteSlice(node.rightHash, w, &n, &err)
- }
- return
-}
-
-// NOTE: clears leftNode/rigthNode recursively
-// NOTE: sets hashes recursively
-func (node *IAVLNode) save(t *IAVLTree) {
- if node.hash == nil {
- node.hash, _ = node.hashWithCount(t)
- }
- if node.persisted {
- return
- }
-
- // save children
- if node.leftNode != nil {
- node.leftNode.save(t)
- node.leftNode = nil
- }
- if node.rightNode != nil {
- node.rightNode.save(t)
- node.rightNode = nil
- }
-
- // save node
- t.ndb.SaveNode(t, node)
- return
-}
-
-// NOTE: sets hashes recursively
-func (node *IAVLNode) writePersistBytes(t *IAVLTree, w io.Writer) (n int, err error) {
- // node header
- wire.WriteInt8(node.height, w, &n, &err)
- wire.WriteVarint(node.size, w, &n, &err)
- // key (unlike writeHashBytes, key is written for inner nodes)
- wire.WriteByteSlice(node.key, w, &n, &err)
-
- if node.height == 0 {
- // value
- wire.WriteByteSlice(node.value, w, &n, &err)
- } else {
- // left
- if node.leftHash == nil {
- PanicSanity("node.leftHash was nil in writePersistBytes")
- }
- wire.WriteByteSlice(node.leftHash, w, &n, &err)
- // right
- if node.rightHash == nil {
- PanicSanity("node.rightHash was nil in writePersistBytes")
- }
- wire.WriteByteSlice(node.rightHash, w, &n, &err)
- }
- return
-}
-
-func (node *IAVLNode) set(t *IAVLTree, key []byte, value []byte) (newSelf *IAVLNode, updated bool) {
- if node.height == 0 {
- cmp := bytes.Compare(key, node.key)
- if cmp < 0 {
- return &IAVLNode{
- key: node.key,
- height: 1,
- size: 2,
- leftNode: NewIAVLNode(key, value),
- rightNode: node,
- }, false
- } else if cmp == 0 {
- removeOrphan(t, node)
- return NewIAVLNode(key, value), true
- } else {
- return &IAVLNode{
- key: key,
- height: 1,
- size: 2,
- leftNode: node,
- rightNode: NewIAVLNode(key, value),
- }, false
- }
- } else {
- removeOrphan(t, node)
- node = node._copy()
- if bytes.Compare(key, node.key) < 0 {
- node.leftNode, updated = node.getLeftNode(t).set(t, key, value)
- node.leftHash = nil // leftHash is yet unknown
- } else {
- node.rightNode, updated = node.getRightNode(t).set(t, key, value)
- node.rightHash = nil // rightHash is yet unknown
- }
- if updated {
- return node, updated
- } else {
- node.calcHeightAndSize(t)
- return node.balance(t), updated
- }
- }
-}
-
-// newHash/newNode: The new hash or node to replace node after remove.
-// newKey: new leftmost leaf key for tree after successfully removing 'key' if changed.
-// value: removed value.
-func (node *IAVLNode) remove(t *IAVLTree, key []byte) (
- newHash []byte, newNode *IAVLNode, newKey []byte, value []byte, removed bool) {
- if node.height == 0 {
- if bytes.Compare(key, node.key) == 0 {
- removeOrphan(t, node)
- return nil, nil, nil, node.value, true
- } else {
- return node.hash, node, nil, nil, false
- }
- } else {
- if bytes.Compare(key, node.key) < 0 {
- var newLeftHash []byte
- var newLeftNode *IAVLNode
- newLeftHash, newLeftNode, newKey, value, removed = node.getLeftNode(t).remove(t, key)
- if !removed {
- return node.hash, node, nil, value, false
- } else if newLeftHash == nil && newLeftNode == nil { // left node held value, was removed
- return node.rightHash, node.rightNode, node.key, value, true
- }
- removeOrphan(t, node)
- node = node._copy()
- node.leftHash, node.leftNode = newLeftHash, newLeftNode
- node.calcHeightAndSize(t)
- node = node.balance(t)
- return node.hash, node, newKey, value, true
- } else {
- var newRightHash []byte
- var newRightNode *IAVLNode
- newRightHash, newRightNode, newKey, value, removed = node.getRightNode(t).remove(t, key)
- if !removed {
- return node.hash, node, nil, value, false
- } else if newRightHash == nil && newRightNode == nil { // right node held value, was removed
- return node.leftHash, node.leftNode, nil, value, true
- }
- removeOrphan(t, node)
- node = node._copy()
- node.rightHash, node.rightNode = newRightHash, newRightNode
- if newKey != nil {
- node.key = newKey
- }
- node.calcHeightAndSize(t)
- node = node.balance(t)
- return node.hash, node, nil, value, true
- }
- }
-}
-
-func (node *IAVLNode) getLeftNode(t *IAVLTree) *IAVLNode {
- if node.leftNode != nil {
- return node.leftNode
- } else {
- return t.ndb.GetNode(t, node.leftHash)
- }
-}
-
-func (node *IAVLNode) getRightNode(t *IAVLTree) *IAVLNode {
- if node.rightNode != nil {
- return node.rightNode
- } else {
- return t.ndb.GetNode(t, node.rightHash)
- }
-}
-
-// NOTE: overwrites node
-// TODO: optimize balance & rotate
-func (node *IAVLNode) rotateRight(t *IAVLTree) *IAVLNode {
- node = node._copy()
- l := node.getLeftNode(t)
- removeOrphan(t, l)
- _l := l._copy()
-
- _lrHash, _lrCached := _l.rightHash, _l.rightNode
- _l.rightHash, _l.rightNode = node.hash, node
- node.leftHash, node.leftNode = _lrHash, _lrCached
-
- node.calcHeightAndSize(t)
- _l.calcHeightAndSize(t)
-
- return _l
-}
-
-// NOTE: overwrites node
-// TODO: optimize balance & rotate
-func (node *IAVLNode) rotateLeft(t *IAVLTree) *IAVLNode {
- node = node._copy()
- r := node.getRightNode(t)
- removeOrphan(t, r)
- _r := r._copy()
-
- _rlHash, _rlCached := _r.leftHash, _r.leftNode
- _r.leftHash, _r.leftNode = node.hash, node
- node.rightHash, node.rightNode = _rlHash, _rlCached
-
- node.calcHeightAndSize(t)
- _r.calcHeightAndSize(t)
-
- return _r
-}
-
-// NOTE: mutates height and size
-func (node *IAVLNode) calcHeightAndSize(t *IAVLTree) {
- node.height = maxInt8(node.getLeftNode(t).height, node.getRightNode(t).height) + 1
- node.size = node.getLeftNode(t).size + node.getRightNode(t).size
-}
-
-func (node *IAVLNode) calcBalance(t *IAVLTree) int {
- return int(node.getLeftNode(t).height) - int(node.getRightNode(t).height)
-}
-
-// NOTE: assumes that node can be modified
-// TODO: optimize balance & rotate
-func (node *IAVLNode) balance(t *IAVLTree) (newSelf *IAVLNode) {
- if node.persisted {
- panic("Unexpected balance() call on persisted node")
- }
- balance := node.calcBalance(t)
- if balance > 1 {
- if node.getLeftNode(t).calcBalance(t) >= 0 {
- // Left Left Case
- return node.rotateRight(t)
- } else {
- // Left Right Case
- // node = node._copy()
- left := node.getLeftNode(t)
- removeOrphan(t, left)
- node.leftHash, node.leftNode = nil, left.rotateLeft(t)
- //node.calcHeightAndSize()
- return node.rotateRight(t)
- }
- }
- if balance < -1 {
- if node.getRightNode(t).calcBalance(t) <= 0 {
- // Right Right Case
- return node.rotateLeft(t)
- } else {
- // Right Left Case
- // node = node._copy()
- right := node.getRightNode(t)
- removeOrphan(t, right)
- node.rightHash, node.rightNode = nil, right.rotateRight(t)
- //node.calcHeightAndSize()
- return node.rotateLeft(t)
- }
- }
- // Nothing changed
- return node
-}
-
-// traverse is a wrapper over traverseInRange when we want the whole tree
-func (node *IAVLNode) traverse(t *IAVLTree, ascending bool, cb func(*IAVLNode) bool) bool {
- return node.traverseInRange(t, nil, nil, ascending, cb)
-}
-
-func (node *IAVLNode) traverseInRange(t *IAVLTree, start, end []byte, ascending bool, cb func(*IAVLNode) bool) bool {
- afterStart := (start == nil || bytes.Compare(start, node.key) <= 0)
- beforeEnd := (end == nil || bytes.Compare(node.key, end) <= 0)
-
- stop := false
- if afterStart && beforeEnd {
- // IterateRange ignores this if not leaf
- stop = cb(node)
- }
- if stop {
- return stop
- }
-
- if node.height > 0 {
- if ascending {
- // check lower nodes, then higher
- if afterStart {
- stop = node.getLeftNode(t).traverseInRange(t, start, end, ascending, cb)
- }
- if stop {
- return stop
- }
- if beforeEnd {
- stop = node.getRightNode(t).traverseInRange(t, start, end, ascending, cb)
- }
- } else {
- // check the higher nodes first
- if beforeEnd {
- stop = node.getRightNode(t).traverseInRange(t, start, end, ascending, cb)
- }
- if stop {
- return stop
- }
- if afterStart {
- stop = node.getLeftNode(t).traverseInRange(t, start, end, ascending, cb)
- }
- }
- }
-
- return stop
-}
-
-// Only used in testing...
-func (node *IAVLNode) lmd(t *IAVLTree) *IAVLNode {
- if node.height == 0 {
- return node
- }
- return node.getLeftNode(t).lmd(t)
-}
-
-// Only used in testing...
-func (node *IAVLNode) rmd(t *IAVLTree) *IAVLNode {
- if node.height == 0 {
- return node
- }
- return node.getRightNode(t).rmd(t)
-}
-
-//----------------------------------------
-
-func removeOrphan(t *IAVLTree, node *IAVLNode) {
- if !node.persisted {
- return
- }
- if t.ndb == nil {
- return
- }
- t.ndb.RemoveNode(t, node)
-}
diff --git a/vendor/github.com/tendermint/merkleeyes/iavl/iavl_proof.go b/vendor/github.com/tendermint/merkleeyes/iavl/iavl_proof.go
deleted file mode 100644
index 95fbf3b7780abed7d7bc9a08ffb6b27e7e78ed46..0000000000000000000000000000000000000000
--- a/vendor/github.com/tendermint/merkleeyes/iavl/iavl_proof.go
+++ /dev/null
@@ -1,153 +0,0 @@
-package iavl
-
-import (
- "bytes"
-
- "golang.org/x/crypto/ripemd160"
-
- . "github.com/tendermint/tmlibs/common"
- "github.com/tendermint/go-wire"
-)
-
-const proofLimit = 1 << 16 // 64 KB
-
-type IAVLProof struct {
- LeafHash []byte
- InnerNodes []IAVLProofInnerNode
- RootHash []byte
-}
-
-func (proof *IAVLProof) Verify(key []byte, value []byte, root []byte) bool {
- if !bytes.Equal(proof.RootHash, root) {
- return false
- }
- leafNode := IAVLProofLeafNode{KeyBytes: key, ValueBytes: value}
- leafHash := leafNode.Hash()
- if !bytes.Equal(leafHash, proof.LeafHash) {
- return false
- }
- hash := leafHash
- for _, branch := range proof.InnerNodes {
- hash = branch.Hash(hash)
- }
- return bytes.Equal(proof.RootHash, hash)
-}
-
-// Please leave this here! I use it in light-client to fulfill an interface
-func (proof *IAVLProof) Root() []byte {
- return proof.RootHash
-}
-
-// ReadProof will deserialize a IAVLProof from bytes
-func ReadProof(data []byte) (*IAVLProof, error) {
- // TODO: make go-wire never panic
- n, err := int(0), error(nil)
- proof := wire.ReadBinary(&IAVLProof{}, bytes.NewBuffer(data), proofLimit, &n, &err).(*IAVLProof)
- return proof, err
-}
-
-type IAVLProofInnerNode struct {
- Height int8
- Size int
- Left []byte
- Right []byte
-}
-
-func (branch IAVLProofInnerNode) Hash(childHash []byte) []byte {
- hasher := ripemd160.New()
- buf := new(bytes.Buffer)
- n, err := int(0), error(nil)
- wire.WriteInt8(branch.Height, buf, &n, &err)
- wire.WriteVarint(branch.Size, buf, &n, &err)
- if len(branch.Left) == 0 {
- wire.WriteByteSlice(childHash, buf, &n, &err)
- wire.WriteByteSlice(branch.Right, buf, &n, &err)
- } else {
- wire.WriteByteSlice(branch.Left, buf, &n, &err)
- wire.WriteByteSlice(childHash, buf, &n, &err)
- }
- if err != nil {
- PanicCrisis(Fmt("Failed to hash IAVLProofInnerNode: %v", err))
- }
- // fmt.Printf("InnerNode hash bytes: %X\n", buf.Bytes())
- hasher.Write(buf.Bytes())
- return hasher.Sum(nil)
-}
-
-type IAVLProofLeafNode struct {
- KeyBytes []byte
- ValueBytes []byte
-}
-
-func (leaf IAVLProofLeafNode) Hash() []byte {
- hasher := ripemd160.New()
- buf := new(bytes.Buffer)
- n, err := int(0), error(nil)
- wire.WriteInt8(0, buf, &n, &err)
- wire.WriteVarint(1, buf, &n, &err)
- wire.WriteByteSlice(leaf.KeyBytes, buf, &n, &err)
- wire.WriteByteSlice(leaf.ValueBytes, buf, &n, &err)
- if err != nil {
- PanicCrisis(Fmt("Failed to hash IAVLProofLeafNode: %v", err))
- }
- // fmt.Printf("LeafNode hash bytes: %X\n", buf.Bytes())
- hasher.Write(buf.Bytes())
- return hasher.Sum(nil)
-}
-
-func (node *IAVLNode) constructProof(t *IAVLTree, key []byte, valuePtr *[]byte, proof *IAVLProof) (exists bool) {
- if node.height == 0 {
- if bytes.Compare(node.key, key) == 0 {
- *valuePtr = node.value
- proof.LeafHash = node.hash
- return true
- } else {
- return false
- }
- } else {
- if bytes.Compare(key, node.key) < 0 {
- exists := node.getLeftNode(t).constructProof(t, key, valuePtr, proof)
- if !exists {
- return false
- }
- branch := IAVLProofInnerNode{
- Height: node.height,
- Size: node.size,
- Left: nil,
- Right: node.getRightNode(t).hash,
- }
- proof.InnerNodes = append(proof.InnerNodes, branch)
- return true
- } else {
- exists := node.getRightNode(t).constructProof(t, key, valuePtr, proof)
- if !exists {
- return false
- }
- branch := IAVLProofInnerNode{
- Height: node.height,
- Size: node.size,
- Left: node.getLeftNode(t).hash,
- Right: nil,
- }
- proof.InnerNodes = append(proof.InnerNodes, branch)
- return true
- }
- }
-}
-
-// Returns nil, nil if key is not in tree.
-func (t *IAVLTree) ConstructProof(key []byte) (value []byte, proof *IAVLProof) {
- if t.root == nil {
- return nil, nil
- }
- t.root.hashWithCount(t) // Ensure that all hashes are calculated.
- proof = &IAVLProof{
- RootHash: t.root.hash,
- }
- exists := t.root.constructProof(t, key, &value, proof)
- if exists {
- return value, proof
- } else {
- return nil, nil
- }
-}
diff --git a/vendor/github.com/tendermint/merkleeyes/iavl/iavl_tree.go b/vendor/github.com/tendermint/merkleeyes/iavl/iavl_tree.go
deleted file mode 100644
index b644612d0051801f596eafd2a829516d4f4cf4ca..0000000000000000000000000000000000000000
--- a/vendor/github.com/tendermint/merkleeyes/iavl/iavl_tree.go
+++ /dev/null
@@ -1,327 +0,0 @@
-package iavl
-
-import (
- "bytes"
- "container/list"
- "sync"
-
- wire "github.com/tendermint/go-wire"
- . "github.com/tendermint/tmlibs/common"
- dbm "github.com/tendermint/tmlibs/db"
- "github.com/tendermint/tmlibs/merkle"
-)
-
-/*
-Immutable AVL Tree (wraps the Node root)
-This tree is not goroutine safe.
-*/
-type IAVLTree struct {
- root *IAVLNode
- ndb *nodeDB
-}
-
-// NewIAVLTree creates both im-memory and persistent instances
-func NewIAVLTree(cacheSize int, db dbm.DB) *IAVLTree {
- if db == nil {
- // In-memory IAVLTree
- return &IAVLTree{}
- } else {
- // Persistent IAVLTree
- ndb := newNodeDB(cacheSize, db)
- return &IAVLTree{
- ndb: ndb,
- }
- }
-}
-
-// The returned tree and the original tree are goroutine independent.
-// That is, they can each run in their own goroutine.
-// However, upon Save(), any other trees that share a db will become
-// outdated, as some nodes will become orphaned.
-// Note that Save() clears leftNode and rightNode. Otherwise,
-// two copies would not be goroutine independent.
-func (t *IAVLTree) Copy() merkle.Tree {
- if t.root == nil {
- return &IAVLTree{
- root: nil,
- ndb: t.ndb,
- }
- }
- if t.ndb != nil && !t.root.persisted {
- // Saving a tree finalizes all the nodes.
- // It sets all the hashes recursively,
- // clears all the leftNode/rightNode values recursively,
- // and all the .persisted flags get set.
- PanicSanity("It is unsafe to Copy() an unpersisted tree.")
- } else if t.ndb == nil && t.root.hash == nil {
- // An in-memory IAVLTree is finalized when the hashes are
- // calculated.
- t.root.hashWithCount(t)
- }
- return &IAVLTree{
- root: t.root,
- ndb: t.ndb,
- }
-}
-
-func (t *IAVLTree) Size() int {
- if t.root == nil {
- return 0
- }
- return t.root.size
-}
-
-func (t *IAVLTree) Height() int8 {
- if t.root == nil {
- return 0
- }
- return t.root.height
-}
-
-func (t *IAVLTree) Has(key []byte) bool {
- if t.root == nil {
- return false
- }
- return t.root.has(t, key)
-}
-
-func (t *IAVLTree) Proof(key []byte) (value []byte, proofBytes []byte, exists bool) {
- value, proof := t.ConstructProof(key)
- if proof == nil {
- return nil, nil, false
- }
- proofBytes = wire.BinaryBytes(proof)
- return value, proofBytes, true
-}
-
-func (t *IAVLTree) Set(key []byte, value []byte) (updated bool) {
- if t.root == nil {
- t.root = NewIAVLNode(key, value)
- return false
- }
- t.root, updated = t.root.set(t, key, value)
- return updated
-}
-
-// BatchSet adds a Set to the current batch, will get handled atomically
-func (t *IAVLTree) BatchSet(key []byte, value []byte) {
- t.ndb.batch.Set(key, value)
-}
-
-func (t *IAVLTree) Hash() []byte {
- if t.root == nil {
- return nil
- }
- hash, _ := t.root.hashWithCount(t)
- return hash
-}
-
-func (t *IAVLTree) HashWithCount() ([]byte, int) {
- if t.root == nil {
- return nil, 0
- }
- return t.root.hashWithCount(t)
-}
-
-func (t *IAVLTree) Save() []byte {
- if t.root == nil {
- return nil
- }
- if t.ndb != nil {
- t.root.save(t)
- t.ndb.Commit()
- }
- return t.root.hash
-}
-
-// Sets the root node by reading from db.
-// If the hash is empty, then sets root to nil.
-func (t *IAVLTree) Load(hash []byte) {
- if len(hash) == 0 {
- t.root = nil
- } else {
- t.root = t.ndb.GetNode(t, hash)
- }
-}
-
-func (t *IAVLTree) Get(key []byte) (index int, value []byte, exists bool) {
- if t.root == nil {
- return 0, nil, false
- }
- return t.root.get(t, key)
-}
-
-func (t *IAVLTree) GetByIndex(index int) (key []byte, value []byte) {
- if t.root == nil {
- return nil, nil
- }
- return t.root.getByIndex(t, index)
-}
-
-func (t *IAVLTree) Remove(key []byte) (value []byte, removed bool) {
- if t.root == nil {
- return nil, false
- }
- newRootHash, newRoot, _, value, removed := t.root.remove(t, key)
- if !removed {
- return nil, false
- }
- if newRoot == nil && newRootHash != nil {
- t.root = t.ndb.GetNode(t, newRootHash)
- } else {
- t.root = newRoot
- }
- return value, true
-}
-
-func (t *IAVLTree) Iterate(fn func(key []byte, value []byte) bool) (stopped bool) {
- if t.root == nil {
- return false
- }
- return t.root.traverse(t, true, func(node *IAVLNode) bool {
- if node.height == 0 {
- return fn(node.key, node.value)
- } else {
- return false
- }
- })
-}
-
-// IterateRange makes a callback for all nodes with key between start and end inclusive
-// If either are nil, then it is open on that side (nil, nil is the same as Iterate)
-func (t *IAVLTree) IterateRange(start, end []byte, ascending bool, fn func(key []byte, value []byte) bool) (stopped bool) {
- if t.root == nil {
- return false
- }
- return t.root.traverseInRange(t, start, end, ascending, func(node *IAVLNode) bool {
- if node.height == 0 {
- return fn(node.key, node.value)
- } else {
- return false
- }
- })
-}
-
-//-----------------------------------------------------------------------------
-
-type nodeDB struct {
- mtx sync.Mutex
- cache map[string]*list.Element
- cacheSize int
- cacheQueue *list.List
- db dbm.DB
- batch dbm.Batch
- orphans map[string]struct{}
- orphansPrev map[string]struct{}
-}
-
-func newNodeDB(cacheSize int, db dbm.DB) *nodeDB {
- ndb := &nodeDB{
- cache: make(map[string]*list.Element),
- cacheSize: cacheSize,
- cacheQueue: list.New(),
- db: db,
- batch: db.NewBatch(),
- orphans: make(map[string]struct{}),
- orphansPrev: make(map[string]struct{}),
- }
- return ndb
-}
-
-func (ndb *nodeDB) GetNode(t *IAVLTree, hash []byte) *IAVLNode {
- ndb.mtx.Lock()
- defer ndb.mtx.Unlock()
- // Check the cache.
- elem, ok := ndb.cache[string(hash)]
- if ok {
- // Already exists. Move to back of cacheQueue.
- ndb.cacheQueue.MoveToBack(elem)
- return elem.Value.(*IAVLNode)
- } else {
- // Doesn't exist, load.
- buf := ndb.db.Get(hash)
- if len(buf) == 0 {
- // ndb.db.Print()
- PanicSanity(Fmt("Value missing for key %X", hash))
- }
- node, err := MakeIAVLNode(buf, t)
- if err != nil {
- PanicCrisis(Fmt("Error reading IAVLNode. bytes: %X error: %v", buf, err))
- }
- node.hash = hash
- node.persisted = true
- ndb.cacheNode(node)
- return node
- }
-}
-
-func (ndb *nodeDB) SaveNode(t *IAVLTree, node *IAVLNode) {
- ndb.mtx.Lock()
- defer ndb.mtx.Unlock()
- if node.hash == nil {
- PanicSanity("Expected to find node.hash, but none found.")
- }
- if node.persisted {
- PanicSanity("Shouldn't be calling save on an already persisted node.")
- }
- /*if _, ok := ndb.cache[string(node.hash)]; ok {
- panic("Shouldn't be calling save on an already cached node.")
- }*/
- // Save node bytes to db
- buf := bytes.NewBuffer(nil)
- _, err := node.writePersistBytes(t, buf)
- if err != nil {
- PanicCrisis(err)
- }
- ndb.batch.Set(node.hash, buf.Bytes())
- node.persisted = true
- ndb.cacheNode(node)
- // Re-creating the orphan,
- // Do not garbage collect.
- delete(ndb.orphans, string(node.hash))
- delete(ndb.orphansPrev, string(node.hash))
-}
-
-func (ndb *nodeDB) RemoveNode(t *IAVLTree, node *IAVLNode) {
- ndb.mtx.Lock()
- defer ndb.mtx.Unlock()
- if node.hash == nil {
- PanicSanity("Expected to find node.hash, but none found.")
- }
- if !node.persisted {
- PanicSanity("Shouldn't be calling remove on a non-persisted node.")
- }
- elem, ok := ndb.cache[string(node.hash)]
- if ok {
- ndb.cacheQueue.Remove(elem)
- delete(ndb.cache, string(node.hash))
- }
- ndb.orphans[string(node.hash)] = struct{}{}
-}
-
-func (ndb *nodeDB) cacheNode(node *IAVLNode) {
- // Create entry in cache and append to cacheQueue.
- elem := ndb.cacheQueue.PushBack(node)
- ndb.cache[string(node.hash)] = elem
- // Maybe expire an item.
- if ndb.cacheQueue.Len() > ndb.cacheSize {
- hash := ndb.cacheQueue.Remove(ndb.cacheQueue.Front()).(*IAVLNode).hash
- delete(ndb.cache, string(hash))
- }
-}
-
-func (ndb *nodeDB) Commit() {
- ndb.mtx.Lock()
- defer ndb.mtx.Unlock()
- // Delete orphans from previous block
- for orphanHashStr, _ := range ndb.orphansPrev {
- ndb.batch.Delete([]byte(orphanHashStr))
- }
- // Write saves & orphan deletes
- ndb.batch.Write()
- ndb.db.SetSync(nil, nil)
- ndb.batch = ndb.db.NewBatch()
- // Shift orphans
- ndb.orphansPrev = ndb.orphans
- ndb.orphans = make(map[string]struct{})
-}
diff --git a/vendor/github.com/tendermint/merkleeyes/iavl/iavl_tree_dump.go b/vendor/github.com/tendermint/merkleeyes/iavl/iavl_tree_dump.go
deleted file mode 100644
index e38a0c4d9a81fdd02d0c8237520d06a35c7a2c32..0000000000000000000000000000000000000000
--- a/vendor/github.com/tendermint/merkleeyes/iavl/iavl_tree_dump.go
+++ /dev/null
@@ -1,144 +0,0 @@
-package iavl
-
-import (
- "bytes"
- "fmt"
- //"strings"
-
- wire "github.com/tendermint/go-wire"
-)
-
-type Formatter func(in []byte) (out string)
-
-type KeyValueMapping struct {
- Key Formatter
- Value Formatter
-}
-
-// Flip back and forth between ascii and hex.
-func mixedDisplay(value []byte) string {
-
- var buffer bytes.Buffer
- var last []byte
-
- ascii := true
- for i := 0; i < len(value); i++ {
- if value[i] < 32 || value[i] > 126 {
- if ascii && len(last) > 0 {
- // only if there are 6 or more chars
- if len(last) > 5 {
- buffer.WriteString(fmt.Sprintf("%s", last))
- last = nil
- }
- ascii = false
- }
- }
- last = append(last, value[i])
- }
- if ascii {
- buffer.WriteString(fmt.Sprintf("%s", last))
- } else {
- buffer.WriteString(fmt.Sprintf("%X", last))
- }
- return buffer.String()
-}
-
-// This is merkleeyes state, that it is writing to a specific key
-type state struct {
- Hash []byte
- Height uint64
-}
-
-// Try to interpet as merkleeyes state
-func stateMapping(value []byte) string {
- var s state
- err := wire.ReadBinaryBytes(value, &s)
- if err != nil || s.Height > 500 {
- return mixedDisplay(value)
- }
- return fmt.Sprintf("Height:%d, [%X]", s.Height, s.Hash)
-}
-
-// This is basecoin accounts, that it is writing to a specific key
-type account struct {
- PubKey []byte
- Sequence int
- Balance []coin
-}
-
-type wrapper struct {
- bytes []byte
-}
-
-type coin struct {
- Denom string
- Amount int64
-}
-
-// Perhaps this is an IAVL tree node?
-func nodeMapping(node *IAVLNode) string {
-
- formattedKey := mixedDisplay(node.key)
-
- var formattedValue string
- var acc account
-
- err := wire.ReadBinaryBytes(node.value, &acc)
- if err != nil {
- formattedValue = mixedDisplay(node.value)
- } else {
- formattedValue = fmt.Sprintf("%v", acc)
- }
-
- if node.height == 0 {
- return fmt.Sprintf(" LeafNode[height: %d, size %d, key: %s, value: %s]",
- node.height, node.size, formattedKey, formattedValue)
- } else {
- return fmt.Sprintf("InnerNode[height: %d, size %d, key: %s, leftHash: %X, rightHash: %X]",
- node.height, node.size, formattedKey, node.leftHash, node.rightHash)
- }
-}
-
-// Try everything and see what sticks...
-func overallMapping(value []byte) (str string) {
- // underneath make node, wire can throw a panic
- defer func() {
- if recover() != nil {
- str = fmt.Sprintf("%X", value)
- return
- }
- }()
-
- // test to see if this is a node
- node, err := MakeIAVLNode(value, nil)
-
- if err == nil && node.height < 100 && node.key != nil {
- return nodeMapping(node)
- }
-
- // Unknown value type
- return stateMapping(value)
-}
-
-// Dump everything from the database
-func (t *IAVLTree) Dump(verbose bool, mapping *KeyValueMapping) {
- if verbose && t.root == nil {
- fmt.Printf("No root loaded into memory\n")
- }
-
- if mapping == nil {
- mapping = &KeyValueMapping{Key: mixedDisplay, Value: overallMapping}
- }
-
- if verbose {
- stats := t.ndb.db.Stats()
- for key, value := range stats {
- fmt.Printf("%s:\n\t%s\n", key, value)
- }
- }
-
- iter := t.ndb.db.Iterator()
- for iter.Next() {
- fmt.Printf("%s: %s\n", mapping.Key(iter.Key()), mapping.Value(iter.Value()))
- }
-}
diff --git a/vendor/github.com/tendermint/merkleeyes/iavl/util.go b/vendor/github.com/tendermint/merkleeyes/iavl/util.go
deleted file mode 100644
index add1c3c2368471dca20835a5e507c78b3bdb0e1c..0000000000000000000000000000000000000000
--- a/vendor/github.com/tendermint/merkleeyes/iavl/util.go
+++ /dev/null
@@ -1,43 +0,0 @@
-package iavl
-
-import (
- "fmt"
-)
-
-// Prints the in-memory children recursively.
-func PrintIAVLNode(node *IAVLNode) {
- fmt.Println("==== NODE")
- if node != nil {
- printIAVLNode(node, 0)
- }
- fmt.Println("==== END")
-}
-
-func printIAVLNode(node *IAVLNode, indent int) {
- indentPrefix := ""
- for i := 0; i < indent; i++ {
- indentPrefix += " "
- }
-
- if node.rightNode != nil {
- printIAVLNode(node.rightNode, indent+1)
- } else if node.rightHash != nil {
- fmt.Printf("%s %X\n", indentPrefix, node.rightHash)
- }
-
- fmt.Printf("%s%v:%v\n", indentPrefix, node.key, node.height)
-
- if node.leftNode != nil {
- printIAVLNode(node.leftNode, indent+1)
- } else if node.leftHash != nil {
- fmt.Printf("%s %X\n", indentPrefix, node.leftHash)
- }
-
-}
-
-func maxInt8(a, b int8) int8 {
- if a > b {
- return a
- }
- return b
-}
diff --git a/vendor/github.com/tendermint/merkleeyes/iavl/version.go b/vendor/github.com/tendermint/merkleeyes/iavl/version.go
deleted file mode 100644
index 0f5a943e1807ac78b9af47732576473f71488648..0000000000000000000000000000000000000000
--- a/vendor/github.com/tendermint/merkleeyes/iavl/version.go
+++ /dev/null
@@ -1,3 +0,0 @@
-package iavl
-
-const Version = "0.4.0" // benchmarking, update proof
diff --git a/vendor/gopkg.in/go-playground/validator.v9/baked_in.go b/vendor/gopkg.in/go-playground/validator.v9/baked_in.go
index 66540946831ab8c67232afa27a9ab5abf931bd2b..231b78ee85af2f7dadbdf505863c354be858bac7 100644
--- a/vendor/gopkg.in/go-playground/validator.v9/baked_in.go
+++ b/vendor/gopkg.in/go-playground/validator.v9/baked_in.go
@@ -6,7 +6,9 @@ import (
"net"
"net/url"
"reflect"
+ "strconv"
"strings"
+ "sync"
"time"
"unicode/utf8"
)
@@ -55,88 +57,130 @@ var (
// you can add, remove or even replace items to suite your needs,
// or even disregard and use your own map if so desired.
bakedInValidators = map[string]Func{
- "required": hasValue,
- "isdefault": isDefault,
- "len": hasLengthOf,
- "min": hasMinOf,
- "max": hasMaxOf,
- "eq": isEq,
- "ne": isNe,
- "lt": isLt,
- "lte": isLte,
- "gt": isGt,
- "gte": isGte,
- "eqfield": isEqField,
- "eqcsfield": isEqCrossStructField,
- "necsfield": isNeCrossStructField,
- "gtcsfield": isGtCrossStructField,
- "gtecsfield": isGteCrossStructField,
- "ltcsfield": isLtCrossStructField,
- "ltecsfield": isLteCrossStructField,
- "nefield": isNeField,
- "gtefield": isGteField,
- "gtfield": isGtField,
- "ltefield": isLteField,
- "ltfield": isLtField,
- "alpha": isAlpha,
- "alphanum": isAlphanum,
- "alphaunicode": isAlphaUnicode,
- "alphanumunicode": isAlphanumUnicode,
- "numeric": isNumeric,
- "number": isNumber,
- "hexadecimal": isHexadecimal,
- "hexcolor": isHEXColor,
- "rgb": isRGB,
- "rgba": isRGBA,
- "hsl": isHSL,
- "hsla": isHSLA,
- "email": isEmail,
- "url": isURL,
- "uri": isURI,
- "base64": isBase64,
- "contains": contains,
- "containsany": containsAny,
- "containsrune": containsRune,
- "excludes": excludes,
- "excludesall": excludesAll,
- "excludesrune": excludesRune,
- "isbn": isISBN,
- "isbn10": isISBN10,
- "isbn13": isISBN13,
- "uuid": isUUID,
- "uuid3": isUUID3,
- "uuid4": isUUID4,
- "uuid5": isUUID5,
- "ascii": isASCII,
- "printascii": isPrintableASCII,
- "multibyte": hasMultiByteCharacter,
- "datauri": isDataURI,
- "latitude": isLatitude,
- "longitude": isLongitude,
- "ssn": isSSN,
- "ipv4": isIPv4,
- "ipv6": isIPv6,
- "ip": isIP,
- "cidrv4": isCIDRv4,
- "cidrv6": isCIDRv6,
- "cidr": isCIDR,
- "tcp4_addr": isTCP4AddrResolvable,
- "tcp6_addr": isTCP6AddrResolvable,
- "tcp_addr": isTCPAddrResolvable,
- "udp4_addr": isUDP4AddrResolvable,
- "udp6_addr": isUDP6AddrResolvable,
- "udp_addr": isUDPAddrResolvable,
- "ip4_addr": isIP4AddrResolvable,
- "ip6_addr": isIP6AddrResolvable,
- "ip_addr": isIPAddrResolvable,
- "unix_addr": isUnixAddrResolvable,
- "mac": isMAC,
- "hostname": isHostname,
- "fqdn": isFQDN,
- "unique": isUnique,
+ "required": hasValue,
+ "isdefault": isDefault,
+ "len": hasLengthOf,
+ "min": hasMinOf,
+ "max": hasMaxOf,
+ "eq": isEq,
+ "ne": isNe,
+ "lt": isLt,
+ "lte": isLte,
+ "gt": isGt,
+ "gte": isGte,
+ "eqfield": isEqField,
+ "eqcsfield": isEqCrossStructField,
+ "necsfield": isNeCrossStructField,
+ "gtcsfield": isGtCrossStructField,
+ "gtecsfield": isGteCrossStructField,
+ "ltcsfield": isLtCrossStructField,
+ "ltecsfield": isLteCrossStructField,
+ "nefield": isNeField,
+ "gtefield": isGteField,
+ "gtfield": isGtField,
+ "ltefield": isLteField,
+ "ltfield": isLtField,
+ "alpha": isAlpha,
+ "alphanum": isAlphanum,
+ "alphaunicode": isAlphaUnicode,
+ "alphanumunicode": isAlphanumUnicode,
+ "numeric": isNumeric,
+ "number": isNumber,
+ "hexadecimal": isHexadecimal,
+ "hexcolor": isHEXColor,
+ "rgb": isRGB,
+ "rgba": isRGBA,
+ "hsl": isHSL,
+ "hsla": isHSLA,
+ "email": isEmail,
+ "url": isURL,
+ "uri": isURI,
+ "base64": isBase64,
+ "contains": contains,
+ "containsany": containsAny,
+ "containsrune": containsRune,
+ "excludes": excludes,
+ "excludesall": excludesAll,
+ "excludesrune": excludesRune,
+ "isbn": isISBN,
+ "isbn10": isISBN10,
+ "isbn13": isISBN13,
+ "uuid": isUUID,
+ "uuid3": isUUID3,
+ "uuid4": isUUID4,
+ "uuid5": isUUID5,
+ "ascii": isASCII,
+ "printascii": isPrintableASCII,
+ "multibyte": hasMultiByteCharacter,
+ "datauri": isDataURI,
+ "latitude": isLatitude,
+ "longitude": isLongitude,
+ "ssn": isSSN,
+ "ipv4": isIPv4,
+ "ipv6": isIPv6,
+ "ip": isIP,
+ "cidrv4": isCIDRv4,
+ "cidrv6": isCIDRv6,
+ "cidr": isCIDR,
+ "tcp4_addr": isTCP4AddrResolvable,
+ "tcp6_addr": isTCP6AddrResolvable,
+ "tcp_addr": isTCPAddrResolvable,
+ "udp4_addr": isUDP4AddrResolvable,
+ "udp6_addr": isUDP6AddrResolvable,
+ "udp_addr": isUDPAddrResolvable,
+ "ip4_addr": isIP4AddrResolvable,
+ "ip6_addr": isIP6AddrResolvable,
+ "ip_addr": isIPAddrResolvable,
+ "unix_addr": isUnixAddrResolvable,
+ "mac": isMAC,
+ "hostname": isHostnameRFC952, // RFC 952
+ "hostname_rfc1123": isHostnameRFC1123, // RFC 1123
+ "fqdn": isFQDN,
+ "unique": isUnique,
+ "oneof": isOneOf,
}
)
+var oneofValsCache = map[string][]string{}
+var oneofValsCacheRWLock = sync.RWMutex{}
+
+func parseOneOfParam2(s string) []string {
+ oneofValsCacheRWLock.RLock()
+ vals, ok := oneofValsCache[s]
+ oneofValsCacheRWLock.RUnlock()
+ if !ok {
+ oneofValsCacheRWLock.Lock()
+ vals = strings.Fields(s)
+ oneofValsCache[s] = vals
+ oneofValsCacheRWLock.Unlock()
+ }
+ return vals
+}
+
+func isOneOf(fl FieldLevel) bool {
+ vals := parseOneOfParam2(fl.Param())
+
+ field := fl.Field()
+
+ var v string
+ switch field.Kind() {
+ case reflect.String:
+ v = field.String()
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ v = strconv.FormatInt(field.Int(), 10)
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ v = strconv.FormatUint(field.Uint(), 10)
+ default:
+ panic(fmt.Sprintf("Bad field type %T", field.Interface()))
+ }
+ for i := 0; i < len(vals); i++ {
+ if vals[i] == v {
+ return true
+ }
+ }
+ return false
+}
+
// isUnique is the validation function for validating if each array|slice element is unique
func isUnique(fl FieldLevel) bool {
@@ -1511,8 +1555,12 @@ func isIP6Addr(fl FieldLevel) bool {
return ip != nil && ip.To4() == nil
}
-func isHostname(fl FieldLevel) bool {
- return hostnameRegex.MatchString(fl.Field().String())
+func isHostnameRFC952(fl FieldLevel) bool {
+ return hostnameRegexRFC952.MatchString(fl.Field().String())
+}
+
+func isHostnameRFC1123(fl FieldLevel) bool {
+ return hostnameRegexRFC1123.MatchString(fl.Field().String())
}
func isFQDN(fl FieldLevel) bool {
@@ -1526,6 +1574,6 @@ func isFQDN(fl FieldLevel) bool {
val = val[0 : len(val)-1]
}
- return (strings.IndexAny(val, ".") > -1) &&
- hostnameRegex.MatchString(val)
+ return strings.ContainsAny(val, ".") &&
+ hostnameRegexRFC952.MatchString(val)
}
diff --git a/vendor/gopkg.in/go-playground/validator.v9/cache.go b/vendor/gopkg.in/go-playground/validator.v9/cache.go
index 3906d2517fcef915616f2ed89986696d7efaf6ec..c7fb0fb1bb773aafe431440777511d037385074f 100644
--- a/vendor/gopkg.in/go-playground/validator.v9/cache.go
+++ b/vendor/gopkg.in/go-playground/validator.v9/cache.go
@@ -91,14 +91,14 @@ type cTag struct {
aliasTag string
actualAliasTag string
param string
- typeof tagType
keys *cTag // only populated when using tag's 'keys' and 'endkeys' for map key validation
next *cTag
+ fn FuncCtx
+ typeof tagType
hasTag bool
hasAlias bool
hasParam bool // true if parameter used eg. eq= where the equal sign has been set
isBlockEnd bool // indicates the current tag represents the last validation in the block
- fn FuncCtx
}
func (v *Validate) extractStructCache(current reflect.Value, sName string) *cStruct {
diff --git a/vendor/gopkg.in/go-playground/validator.v9/doc.go b/vendor/gopkg.in/go-playground/validator.v9/doc.go
index f0a748d41cfa2faea3ff734bbbaa898ee95f3188..f7efe234bef2783863beca9ec451fe8d9af4d67c 100644
--- a/vendor/gopkg.in/go-playground/validator.v9/doc.go
+++ b/vendor/gopkg.in/go-playground/validator.v9/doc.go
@@ -295,6 +295,16 @@ validates the number of items.
Usage: ne=10
+One Of
+
+For strings, ints, and uints, oneof will ensure that the value
+is one of the values in the parameter. The parameter should be
+a list of values separated by whitespace. Values may be
+strings or numbers.
+
+ Usage: oneof=red green
+ oneof=5 7 9
+
Greater Than
For numbers, this will ensure that the value is greater than the
@@ -832,12 +842,18 @@ Note: See Go's ParseMAC for accepted formats and types:
http://golang.org/src/net/mac.go?s=866:918#L29
-Hostname
+Hostname RFC 952
-This validates that a string value is a valid Hostname
+This validates that a string value is a valid Hostname according to RFC 952 https://tools.ietf.org/html/rfc952
Usage: hostname
+Hostname RFC 1123
+
+This validates that a string value is a valid Hostname according to RFC 1123 https://tools.ietf.org/html/rfc1123
+
+ Usage: hostname_rfc1123 or if you want to continue to use 'hostname' in your tags, create an alias.
+
Full Qualified Domain Name (FQDN)
This validates that a string value contains a valid FQDN.
diff --git a/vendor/gopkg.in/go-playground/validator.v9/regexes.go b/vendor/gopkg.in/go-playground/validator.v9/regexes.go
index ec78cebc5cfbc7f5df98443de8835fdb0c2bf3b2..78f3ea0aa1b7939834b8e14934201c4101b933fc 100644
--- a/vendor/gopkg.in/go-playground/validator.v9/regexes.go
+++ b/vendor/gopkg.in/go-playground/validator.v9/regexes.go
@@ -30,7 +30,8 @@ const (
latitudeRegexString = "^[-+]?([1-8]?\\d(\\.\\d+)?|90(\\.0+)?)$"
longitudeRegexString = "^[-+]?(180(\\.0+)?|((1[0-7]\\d)|([1-9]?\\d))(\\.\\d+)?)$"
sSNRegexString = `^\d{3}[- ]?\d{2}[- ]?\d{4}$`
- hostnameRegexString = `^[a-zA-Z][a-zA-Z0-9\-\.]+[a-z-Az0-9]$`
+ hostnameRegexStringRFC952 = `^[a-zA-Z][a-zA-Z0-9\-\.]+[a-z-Az0-9]$` // https://tools.ietf.org/html/rfc952
+ hostnameRegexStringRFC1123 = `^[a-zA-Z0-9][a-zA-Z0-9\-\.]+[a-z-Az0-9]$` // accepts hostname starting with a digit https://tools.ietf.org/html/rfc1123
)
var (
@@ -61,5 +62,6 @@ var (
latitudeRegex = regexp.MustCompile(latitudeRegexString)
longitudeRegex = regexp.MustCompile(longitudeRegexString)
sSNRegex = regexp.MustCompile(sSNRegexString)
- hostnameRegex = regexp.MustCompile(hostnameRegexString)
+ hostnameRegexRFC952 = regexp.MustCompile(hostnameRegexStringRFC952)
+ hostnameRegexRFC1123 = regexp.MustCompile(hostnameRegexStringRFC1123)
)
diff --git a/vendor/gopkg.in/go-playground/validator.v9/util.go b/vendor/gopkg.in/go-playground/validator.v9/util.go
index a01d4b16ed8862b6cd3f9ae594672e64870e75ba..16a5517c97b1ed78248c35d21ac9f5f49c403c36 100644
--- a/vendor/gopkg.in/go-playground/validator.v9/util.go
+++ b/vendor/gopkg.in/go-playground/validator.v9/util.go
@@ -80,7 +80,7 @@ BEGIN:
typ := current.Type()
fld := namespace
- ns := namespace
+ var ns string
if typ != timeType {
diff --git a/vendor/gopkg.in/go-playground/validator.v9/validator.go b/vendor/gopkg.in/go-playground/validator.v9/validator.go
index 5fbb1660db435fd08d12b60f580346478245a4da..483e0a2bea8f688b51d077e8aa1c3ba85491b24b 100644
--- a/vendor/gopkg.in/go-playground/validator.v9/validator.go
+++ b/vendor/gopkg.in/go-playground/validator.v9/validator.go
@@ -14,24 +14,19 @@ type validate struct {
ns []byte
actualNs []byte
errs ValidationErrors
+ includeExclude map[string]struct{} // reset only if StructPartial or StructExcept are called, no need otherwise
+ ffn FilterFunc
+ slflParent reflect.Value // StructLevel & FieldLevel
+ slCurrent reflect.Value // StructLevel & FieldLevel
+ flField reflect.Value // StructLevel & FieldLevel
+ cf *cField // StructLevel & FieldLevel
+ ct *cTag // StructLevel & FieldLevel
+ misc []byte // misc reusable
+ str1 string // misc reusable
+ str2 string // misc reusable
+ fldIsPointer bool // StructLevel & FieldLevel
isPartial bool
hasExcludes bool
- includeExclude map[string]struct{} // reset only if StructPartial or StructExcept are called, no need otherwise
-
- ffn FilterFunc
-
- // StructLevel & FieldLevel fields
- slflParent reflect.Value
- slCurrent reflect.Value
- flField reflect.Value
- fldIsPointer bool
- cf *cField
- ct *cTag
-
- // misc reusable values
- misc []byte
- str1 string
- str2 string
}
// parent and current will be the same the first run of validateStruct
@@ -127,7 +122,6 @@ func (v *validate) traverseField(ctx context.Context, parent reflect.Value, curr
}
if kind == reflect.Invalid {
-
v.errs = append(v.errs,
&fieldError{
v: v.v,
diff --git a/vendor/gopkg.in/go-playground/validator.v9/validator_instance.go b/vendor/gopkg.in/go-playground/validator.v9/validator_instance.go
index f4b49a84c6a8ebc226a9d99994c3f4c6d5ab7446..e84b452dba7779277989e07c1dd9ef477756f173 100644
--- a/vendor/gopkg.in/go-playground/validator.v9/validator_instance.go
+++ b/vendor/gopkg.in/go-playground/validator.v9/validator_instance.go
@@ -370,39 +370,37 @@ func (v *Validate) StructPartialCtx(ctx context.Context, s interface{}, fields .
typ := val.Type()
name := typ.Name()
- if fields != nil {
- for _, k := range fields {
+ for _, k := range fields {
- flds := strings.Split(k, namespaceSeparator)
- if len(flds) > 0 {
+ flds := strings.Split(k, namespaceSeparator)
+ if len(flds) > 0 {
- vd.misc = append(vd.misc[0:0], name...)
- vd.misc = append(vd.misc, '.')
-
- for _, s := range flds {
+ vd.misc = append(vd.misc[0:0], name...)
+ vd.misc = append(vd.misc, '.')
- idx := strings.Index(s, leftBracket)
+ for _, s := range flds {
- if idx != -1 {
- for idx != -1 {
- vd.misc = append(vd.misc, s[:idx]...)
- vd.includeExclude[string(vd.misc)] = struct{}{}
+ idx := strings.Index(s, leftBracket)
- idx2 := strings.Index(s, rightBracket)
- idx2++
- vd.misc = append(vd.misc, s[idx:idx2]...)
- vd.includeExclude[string(vd.misc)] = struct{}{}
- s = s[idx2:]
- idx = strings.Index(s, leftBracket)
- }
- } else {
+ if idx != -1 {
+ for idx != -1 {
+ vd.misc = append(vd.misc, s[:idx]...)
+ vd.includeExclude[string(vd.misc)] = struct{}{}
- vd.misc = append(vd.misc, s...)
+ idx2 := strings.Index(s, rightBracket)
+ idx2++
+ vd.misc = append(vd.misc, s[idx:idx2]...)
vd.includeExclude[string(vd.misc)] = struct{}{}
+ s = s[idx2:]
+ idx = strings.Index(s, leftBracket)
}
+ } else {
- vd.misc = append(vd.misc, '.')
+ vd.misc = append(vd.misc, s...)
+ vd.includeExclude[string(vd.misc)] = struct{}{}
}
+
+ vd.misc = append(vd.misc, '.')
}
}
}