aboutsummaryrefslogtreecommitdiffstats
path: root/core
diff options
context:
space:
mode:
Diffstat (limited to 'core')
-rw-r--r--core/asm.go2
-rw-r--r--core/blockchain.go6
-rw-r--r--core/database_util.go2
-rw-r--r--core/database_util_test.go6
-rw-r--r--core/state/dump.go16
-rw-r--r--core/state/state_object.go2
-rw-r--r--core/state/state_test.go18
-rw-r--r--core/state/sync_test.go10
-rw-r--r--core/types/block.go3
-rw-r--r--core/vm/asm.go2
-rw-r--r--core/vm/jit_util_test.go2
11 files changed, 43 insertions, 26 deletions
diff --git a/core/asm.go b/core/asm.go
index a86a2c44c..b2e47b5e9 100644
--- a/core/asm.go
+++ b/core/asm.go
@@ -61,6 +61,4 @@ func Disassemble(script []byte) (asm []string) {
pc.Add(pc, common.Big1)
}
-
- return asm
}
diff --git a/core/blockchain.go b/core/blockchain.go
index 177a3bbce..ecf8297cb 100644
--- a/core/blockchain.go
+++ b/core/blockchain.go
@@ -678,7 +678,7 @@ func (self *BlockChain) InsertReceiptChain(blockChain types.Blocks, receiptChain
}
}
// Write all the data out into the database
- if err := WriteBody(self.chainDb, block.Hash(), &types.Body{block.Transactions(), block.Uncles()}); err != nil {
+ if err := WriteBody(self.chainDb, block.Hash(), block.Body()); err != nil {
errs[index] = fmt.Errorf("failed to write block body: %v", err)
atomic.AddInt32(&failed, 1)
glog.Fatal(errs[index])
@@ -993,7 +993,7 @@ func (self *BlockChain) reorg(oldBlock, newBlock *types.Block) error {
// first reduce whoever is higher bound
if oldBlock.NumberU64() > newBlock.NumberU64() {
// reduce old chain
- for oldBlock = oldBlock; oldBlock != nil && oldBlock.NumberU64() != newBlock.NumberU64(); oldBlock = self.GetBlock(oldBlock.ParentHash()) {
+ for ; oldBlock != nil && oldBlock.NumberU64() != newBlock.NumberU64(); oldBlock = self.GetBlock(oldBlock.ParentHash()) {
oldChain = append(oldChain, oldBlock)
deletedTxs = append(deletedTxs, oldBlock.Transactions()...)
@@ -1001,7 +1001,7 @@ func (self *BlockChain) reorg(oldBlock, newBlock *types.Block) error {
}
} else {
// reduce new chain and append new chain blocks for inserting later on
- for newBlock = newBlock; newBlock != nil && newBlock.NumberU64() != oldBlock.NumberU64(); newBlock = self.GetBlock(newBlock.ParentHash()) {
+ for ; newBlock != nil && newBlock.NumberU64() != oldBlock.NumberU64(); newBlock = self.GetBlock(newBlock.ParentHash()) {
newChain = append(newChain, newBlock)
}
}
diff --git a/core/database_util.go b/core/database_util.go
index e1e8136d1..3ba80062c 100644
--- a/core/database_util.go
+++ b/core/database_util.go
@@ -318,7 +318,7 @@ func WriteTd(db ethdb.Database, hash common.Hash, td *big.Int) error {
// WriteBlock serializes a block into the database, header and body separately.
func WriteBlock(db ethdb.Database, block *types.Block) error {
// Store the body first to retain database consistency
- if err := WriteBody(db, block.Hash(), &types.Body{block.Transactions(), block.Uncles()}); err != nil {
+ if err := WriteBody(db, block.Hash(), block.Body()); err != nil {
return err
}
// Store the header too, signaling full block ownership
diff --git a/core/database_util_test.go b/core/database_util_test.go
index ce1ffea8a..9ef787624 100644
--- a/core/database_util_test.go
+++ b/core/database_util_test.go
@@ -196,7 +196,7 @@ func TestBlockStorage(t *testing.T) {
if entry := GetBody(db, block.Hash()); entry == nil {
t.Fatalf("Stored body not found")
} else if types.DeriveSha(types.Transactions(entry.Transactions)) != types.DeriveSha(block.Transactions()) || types.CalcUncleHash(entry.Uncles) != types.CalcUncleHash(block.Uncles()) {
- t.Fatalf("Retrieved body mismatch: have %v, want %v", entry, &types.Body{block.Transactions(), block.Uncles()})
+ t.Fatalf("Retrieved body mismatch: have %v, want %v", entry, block.Body())
}
// Delete the block and verify the execution
DeleteBlock(db, block.Hash())
@@ -230,7 +230,7 @@ func TestPartialBlockStorage(t *testing.T) {
DeleteHeader(db, block.Hash())
// Store a body and check that it's not recognized as a block
- if err := WriteBody(db, block.Hash(), &types.Body{block.Transactions(), block.Uncles()}); err != nil {
+ if err := WriteBody(db, block.Hash(), block.Body()); err != nil {
t.Fatalf("Failed to write body into database: %v", err)
}
if entry := GetBlock(db, block.Hash()); entry != nil {
@@ -242,7 +242,7 @@ func TestPartialBlockStorage(t *testing.T) {
if err := WriteHeader(db, block.Header()); err != nil {
t.Fatalf("Failed to write header into database: %v", err)
}
- if err := WriteBody(db, block.Hash(), &types.Body{block.Transactions(), block.Uncles()}); err != nil {
+ if err := WriteBody(db, block.Hash(), block.Body()); err != nil {
t.Fatalf("Failed to write body into database: %v", err)
}
if entry := GetBlock(db, block.Hash()); entry == nil {
diff --git a/core/state/dump.go b/core/state/dump.go
index 8eb03e8e4..a328b0537 100644
--- a/core/state/dump.go
+++ b/core/state/dump.go
@@ -46,11 +46,19 @@ func (self *StateDB) RawDump() World {
it := self.trie.Iterator()
for it.Next() {
addr := self.trie.GetKey(it.Key)
- stateObject, _ := DecodeObject(common.BytesToAddress(addr), self.db, it.Value)
-
- account := Account{Balance: stateObject.balance.String(), Nonce: stateObject.nonce, Root: common.Bytes2Hex(stateObject.Root()), CodeHash: common.Bytes2Hex(stateObject.codeHash), Code: common.Bytes2Hex(stateObject.Code())}
- account.Storage = make(map[string]string)
+ stateObject, err := DecodeObject(common.BytesToAddress(addr), self.db, it.Value)
+ if err != nil {
+ panic(err)
+ }
+ account := Account{
+ Balance: stateObject.balance.String(),
+ Nonce: stateObject.nonce,
+ Root: common.Bytes2Hex(stateObject.Root()),
+ CodeHash: common.Bytes2Hex(stateObject.codeHash),
+ Code: common.Bytes2Hex(stateObject.Code()),
+ Storage: make(map[string]string),
+ }
storageIt := stateObject.trie.Iterator()
for storageIt.Next() {
account.Storage[common.Bytes2Hex(self.trie.GetKey(storageIt.Key))] = common.Bytes2Hex(storageIt.Value)
diff --git a/core/state/state_object.go b/core/state/state_object.go
index 326708118..769c63d42 100644
--- a/core/state/state_object.go
+++ b/core/state/state_object.go
@@ -287,7 +287,7 @@ func DecodeObject(address common.Address, db trie.Database, data []byte) (*State
}
if !bytes.Equal(ext.CodeHash, emptyCodeHash) {
if obj.code, err = db.Get(ext.CodeHash); err != nil {
- return nil, fmt.Errorf("can't find code for hash %x: %v", ext.CodeHash, err)
+ return nil, fmt.Errorf("can't get code for hash %x: %v", ext.CodeHash, err)
}
}
obj.nonce = ext.Nonce
diff --git a/core/state/state_test.go b/core/state/state_test.go
index a45eddd0d..ce86a5b76 100644
--- a/core/state/state_test.go
+++ b/core/state/state_test.go
@@ -36,7 +36,6 @@ var _ = checker.Suite(&StateSuite{})
var toAddr = common.BytesToAddress
func (s *StateSuite) TestDump(c *checker.C) {
- return
// generate a few entries
obj1 := s.state.GetOrNewStateObject(toAddr([]byte{0x01}))
obj1.AddBalance(big.NewInt(22))
@@ -48,24 +47,35 @@ func (s *StateSuite) TestDump(c *checker.C) {
// write some of them to the trie
s.state.UpdateStateObject(obj1)
s.state.UpdateStateObject(obj2)
+ s.state.Commit()
// check that dump contains the state objects that are in trie
got := string(s.state.Dump())
want := `{
- "root": "6e277ae8357d013e50f74eedb66a991f6922f93ae03714de58b3d0c5e9eee53f",
+ "root": "71edff0130dd2385947095001c73d9e28d862fc286fca2b922ca6f6f3cddfdd2",
"accounts": {
- "1468288056310c82aa4c01a7e12a10f8111a0560e72b700555479031b86c357d": {
+ "0000000000000000000000000000000000000001": {
"balance": "22",
"nonce": 0,
"root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
"codeHash": "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
+ "code": "",
"storage": {}
},
- "a17eacbc25cda025e81db9c5c62868822c73ce097cee2a63e33a2e41268358a1": {
+ "0000000000000000000000000000000000000002": {
+ "balance": "44",
+ "nonce": 0,
+ "root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
+ "codeHash": "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
+ "code": "",
+ "storage": {}
+ },
+ "0000000000000000000000000000000000000102": {
"balance": "0",
"nonce": 0,
"root": "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421",
"codeHash": "87874902497a5bb968da31a2998d8f22e949d1ef6214bcdedd8bae24cca4b9e3",
+ "code": "03030303030303",
"storage": {}
}
}
diff --git a/core/state/sync_test.go b/core/state/sync_test.go
index a2a1edbdb..715645c6c 100644
--- a/core/state/sync_test.go
+++ b/core/state/sync_test.go
@@ -145,7 +145,7 @@ func testIterativeStateSync(t *testing.T, batch int) {
if err != nil {
t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
}
- results[i] = trie.SyncResult{hash, data}
+ results[i] = trie.SyncResult{Hash: hash, Data: data}
}
if index, err := sched.Process(results); err != nil {
t.Fatalf("failed to process result #%d: %v", index, err)
@@ -175,7 +175,7 @@ func TestIterativeDelayedStateSync(t *testing.T) {
if err != nil {
t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
}
- results[i] = trie.SyncResult{hash, data}
+ results[i] = trie.SyncResult{Hash: hash, Data: data}
}
if index, err := sched.Process(results); err != nil {
t.Fatalf("failed to process result #%d: %v", index, err)
@@ -212,7 +212,7 @@ func testIterativeRandomStateSync(t *testing.T, batch int) {
if err != nil {
t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
}
- results = append(results, trie.SyncResult{hash, data})
+ results = append(results, trie.SyncResult{Hash: hash, Data: data})
}
// Feed the retrieved results back and queue new tasks
if index, err := sched.Process(results); err != nil {
@@ -251,7 +251,7 @@ func TestIterativeRandomDelayedStateSync(t *testing.T) {
if err != nil {
t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
}
- results = append(results, trie.SyncResult{hash, data})
+ results = append(results, trie.SyncResult{Hash: hash, Data: data})
if len(results) >= cap(results) {
break
@@ -289,7 +289,7 @@ func TestIncompleteStateSync(t *testing.T) {
if err != nil {
t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
}
- results[i] = trie.SyncResult{hash, data}
+ results[i] = trie.SyncResult{Hash: hash, Data: data}
}
// Process each of the state nodes
if index, err := sched.Process(results); err != nil {
diff --git a/core/types/block.go b/core/types/block.go
index 5e6a9019d..387a063ae 100644
--- a/core/types/block.go
+++ b/core/types/block.go
@@ -330,6 +330,9 @@ func (b *Block) Extra() []byte { return common.CopyBytes(b.header.Ext
func (b *Block) Header() *Header { return CopyHeader(b.header) }
+// Body returns the non-header content of the block.
+func (b *Block) Body() *Body { return &Body{b.transactions, b.uncles} }
+
func (b *Block) HashNoNonce() common.Hash {
return b.header.HashNoNonce()
}
diff --git a/core/vm/asm.go b/core/vm/asm.go
index b248838a7..d7dbde5e8 100644
--- a/core/vm/asm.go
+++ b/core/vm/asm.go
@@ -58,6 +58,4 @@ func Disassemble(script []byte) (asm []string) {
pc.Add(pc, common.Big1)
}
-
- return
}
diff --git a/core/vm/jit_util_test.go b/core/vm/jit_util_test.go
index 1f4cb2b16..2123efe59 100644
--- a/core/vm/jit_util_test.go
+++ b/core/vm/jit_util_test.go
@@ -77,7 +77,7 @@ func TestParser(t *testing.T) {
t.Fatal("empty output")
}
if output[0] != test.output {
- t.Error("%v failed: expected %v but got %v", test.base+OpCode(i), output[0])
+ t.Errorf("%v failed: expected %v but got %v", test.base+OpCode(i), test.output, output[0])
}
}
}
generated by cgit (git 2.34.1) at 2024-10-18 02:37:19 +0800