PoS_EVM
/
woop
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

explicitly return tx verification error and increase block tx num

Browse Source
pull/69/head
Rongjian Lan 6 years ago
parent 028512ad81
commit 514262be2e
5 changed files with 68 additions and 58 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 55
      blockchain/utxopool.go
  2. 4
      blockchain/utxopool_test.go
  3. 20
      client/txgen/main.go
  4. 3
      node/node.go
  5. 4
      node/node_handler.go

55
blockchain/utxopool.go
Unescape View File

@ -4,6 +4,7 @@ import (
"bytes" "bytes"
"encoding/gob" "encoding/gob"
"encoding/hex" "encoding/hex"
"errors"
"fmt" "fmt"
"github.com/dedis/kyber/sign/schnorr" "github.com/dedis/kyber/sign/schnorr"
"github.com/simple-rules/harmony-benchmark/crypto" "github.com/simple-rules/harmony-benchmark/crypto"
@ -77,7 +78,7 @@ func (utxoPool *UTXOPool) VerifyTransactions(transactions []*Transaction) bool {
spentTXOs := make(map[[20]byte]map[string]map[uint32]bool) spentTXOs := make(map[[20]byte]map[string]map[uint32]bool)
if utxoPool != nil { if utxoPool != nil {
for _, tx := range transactions { for _, tx := range transactions {
if valid, crossShard := utxoPool.VerifyOneTransaction(tx, &spentTXOs); !crossShard && !valid { if err, crossShard := utxoPool.VerifyOneTransaction(tx, &spentTXOs); !crossShard && err != nil {
return false return false
} }
} }
@ -114,7 +115,7 @@ func (utxoPool *UTXOPool) VerifyStateBlock(stateBlock *Block) bool {
} }
// VerifyOneTransaction verifies if a list of transactions valid. // VerifyOneTransaction verifies if a list of transactions valid.
func (utxoPool *UTXOPool) VerifyOneTransaction(tx *Transaction, spentTXOs *map[[20]byte]map[string]map[uint32]bool) (valid, crossShard bool) { func (utxoPool *UTXOPool) VerifyOneTransaction(tx *Transaction, spentTXOs *map[[20]byte]map[string]map[uint32]bool) (err error, crossShard bool) {
if len(tx.Proofs) != 0 { if len(tx.Proofs) != 0 {
return utxoPool.VerifyUnlockTransaction(tx) return utxoPool.VerifyUnlockTransaction(tx)
} }
@ -133,10 +134,10 @@ func (utxoPool *UTXOPool) VerifyOneTransaction(tx *Transaction, spentTXOs *map[[
inTxID := hex.EncodeToString(in.PreviousOutPoint.TxID[:]) inTxID := hex.EncodeToString(in.PreviousOutPoint.TxID[:])
index := in.PreviousOutPoint.Index index := in.PreviousOutPoint.Index
// Check if the transaction with the addres is spent or not. // Check if the transaction with the address is spent or not.
if val, ok := (*spentTXOs)[in.Address][inTxID][index]; ok { if val, ok := (*spentTXOs)[in.Address][inTxID][index]; ok {
if val { if val {
return false, crossShard return errors.New("TxInput is already spent"), crossShard
} }
} }
// Mark the transactions with the address and index spent. // Mark the transactions with the address and index spent.
@ -154,7 +155,7 @@ func (utxoPool *UTXOPool) VerifyOneTransaction(tx *Transaction, spentTXOs *map[[
inTotal += val inTotal += val
} else { } else {
utxoPool.mutex.Unlock() utxoPool.mutex.Unlock()
return false, crossShard return errors.New("Specified TxInput does not exist in utxo pool"), crossShard
} }
utxoPool.mutex.Unlock() utxoPool.mutex.Unlock()
} }
@ -171,30 +172,30 @@ func (utxoPool *UTXOPool) VerifyOneTransaction(tx *Transaction, spentTXOs *map[[
// TODO: improve this checking logic // TODO: improve this checking logic
if (crossShard && inTotal > outTotal) || (!crossShard && inTotal != outTotal) { if (crossShard && inTotal > outTotal) || (!crossShard && inTotal != outTotal) {
return false, crossShard return errors.New("Input and output amount doesn't match"), crossShard
} }
if inTotal == 0 { if inTotal == 0 {
return false, false // Here crossShard is false, because if there is no business for this shard, it's effectively not crossShard no matter what. return errors.New("Input amount is 0"), false // Here crossShard is false, because if there is no business for this shard, it's effectively not crossShard no matter what.
} }
// Verify the signature // Verify the signature
pubKey := crypto.Ed25519Curve.Point() pubKey := crypto.Ed25519Curve.Point()
err := pubKey.UnmarshalBinary(tx.PublicKey[:]) tempErr := pubKey.UnmarshalBinary(tx.PublicKey[:])
if err != nil { if tempErr != nil {
log.Error("Failed to deserialize public key", "error", err) log.Error("Failed to deserialize public key", "error", tempErr)
} }
err = schnorr.Verify(crypto.Ed25519Curve, pubKey, tx.GetContentToVerify(), tx.Signature[:]) tempErr = schnorr.Verify(crypto.Ed25519Curve, pubKey, tx.GetContentToVerify(), tx.Signature[:])
if err != nil { if tempErr != nil {
log.Error("Failed to verify signature", "error", err, "public key", pubKey, "pubKey in bytes", tx.PublicKey[:]) log.Error("Failed to verify signature", "error", tempErr, "public key", pubKey, "pubKey in bytes", tx.PublicKey[:])
return false, crossShard return errors.New("Invalid signature"), crossShard
} }
return true, crossShard return nil, crossShard
} }
// Verify a cross shard transaction that contains proofs for unlock-to-commit/abort. // Verify a cross shard transaction that contains proofs for unlock-to-commit/abort.
func (utxoPool *UTXOPool) VerifyUnlockTransaction(tx *Transaction) (valid, crossShard bool) { func (utxoPool *UTXOPool) VerifyUnlockTransaction(tx *Transaction) (err error, crossShard bool) {
valid = true err = nil
crossShard = false // unlock transaction is treated as crossShard=false because it will be finalized now (doesn't need more steps) crossShard = false // unlock transaction is treated as crossShard=false because it will be finalized now (doesn't need more steps)
txInputs := make(map[TXInput]bool) txInputs := make(map[TXInput]bool)
for _, curProof := range tx.Proofs { for _, curProof := range tx.Proofs {
@ -205,7 +206,7 @@ func (utxoPool *UTXOPool) VerifyUnlockTransaction(tx *Transaction) (valid, cross
for _, txInput := range tx.TxInput { for _, txInput := range tx.TxInput {
val, ok := txInputs[txInput] val, ok := txInputs[txInput]
if !ok || !val { if !ok || !val {
valid = false err = errors.New("Invalid unlock transaction: not all proofs are provided for tx inputs")
} }
} }
return return
@ -346,7 +347,7 @@ func (utxoPool *UTXOPool) UpdateOneTransaction(tx *Transaction) {
// VerifyOneTransactionAndUpdate verifies and update a valid transaction. // VerifyOneTransactionAndUpdate verifies and update a valid transaction.
// Return false if the transaction is not valid. // Return false if the transaction is not valid.
func (utxoPool *UTXOPool) VerifyOneTransactionAndUpdate(tx *Transaction) bool { func (utxoPool *UTXOPool) VerifyOneTransactionAndUpdate(tx *Transaction) bool {
if valid, _ := utxoPool.VerifyOneTransaction(tx, nil); valid { if err, _ := utxoPool.VerifyOneTransaction(tx, nil); err == nil {
utxoPool.UpdateOneTransaction(tx) utxoPool.UpdateOneTransaction(tx)
return true return true
} }
@ -385,29 +386,33 @@ func CreateUTXOPoolFromGenesisBlockChain(bc *Blockchain) *UTXOPool {
} }
// SelectTransactionsForNewBlock returns a list of index of valid transactions for the new block. // SelectTransactionsForNewBlock returns a list of index of valid transactions for the new block.
func (utxoPool *UTXOPool) SelectTransactionsForNewBlock(transactions []*Transaction, maxNumTxs int) ([]*Transaction, []*Transaction, []*CrossShardTxAndProof) { func (utxoPool *UTXOPool) SelectTransactionsForNewBlock(transactions []*Transaction, maxNumTxs int) ([]*Transaction, []*Transaction, []*Transaction, []*CrossShardTxAndProof) {
selected, unselected, crossShardTxs := []*Transaction{}, []*Transaction{}, []*CrossShardTxAndProof{} selected, unselected, invalid, crossShardTxs := []*Transaction{}, []*Transaction{}, []*Transaction{}, []*CrossShardTxAndProof{}
spentTXOs := make(map[[20]byte]map[string]map[uint32]bool) spentTXOs := make(map[[20]byte]map[string]map[uint32]bool)
for _, tx := range transactions { for _, tx := range transactions {
valid, crossShard := utxoPool.VerifyOneTransaction(tx, &spentTXOs) err, crossShard := utxoPool.VerifyOneTransaction(tx, &spentTXOs)
if len(selected) < maxNumTxs { if len(selected) < maxNumTxs {
if valid || crossShard { if err == nil || crossShard {
selected = append(selected, tx) selected = append(selected, tx)
if crossShard { if crossShard {
proof := CrossShardTxProof{Accept: valid, TxID: tx.ID, TxInput: getShardTxInput(tx, utxoPool.ShardID)} proof := CrossShardTxProof{Accept: err == nil, TxID: tx.ID, TxInput: getShardTxInput(tx, utxoPool.ShardID)}
txAndProof := CrossShardTxAndProof{tx, &proof} txAndProof := CrossShardTxAndProof{tx, &proof}
crossShardTxs = append(crossShardTxs, &txAndProof) crossShardTxs = append(crossShardTxs, &txAndProof)
} }
} else { } else {
//if err != nil {
// log.Warn("Tx Verification failed", "Error:", err)
//}
unselected = append(unselected, tx) unselected = append(unselected, tx)
invalid = append(invalid, tx)
} }
} else { } else {
// TODO: discard invalid transactions // TODO: discard invalid transactions
unselected = append(unselected, tx) unselected = append(unselected, tx)
} }
} }
return selected, unselected, crossShardTxs return selected, unselected, invalid, crossShardTxs
} }
func getShardTxInput(transaction *Transaction, shardID uint32) []TXInput { func getShardTxInput(transaction *Transaction, shardID uint32) []TXInput {

4
blockchain/utxopool_test.go
Unescape View File

@ -16,7 +16,7 @@ func TestVerifyOneTransactionAndUpdate(t *testing.T) {
t.Error("failed to create a new transaction.") t.Error("failed to create a new transaction.")
} }
if valid, _ := utxoPool.VerifyOneTransaction(tx, nil); !valid { if err, _ := utxoPool.VerifyOneTransaction(tx, nil); err != nil {
t.Error("failed to verify a valid transaction.") t.Error("failed to verify a valid transaction.")
} }
utxoPool.VerifyOneTransactionAndUpdate(tx) utxoPool.VerifyOneTransactionAndUpdate(tx)
@ -35,7 +35,7 @@ func TestVerifyOneTransactionFail(t *testing.T) {
} }
tx.TxInput = append(tx.TxInput, tx.TxInput[0]) tx.TxInput = append(tx.TxInput, tx.TxInput[0])
if valid, _ := utxoPool.VerifyOneTransaction(tx, nil); valid { if err, _ := utxoPool.VerifyOneTransaction(tx, nil); err == nil {
t.Error("Tx with multiple identical TxInput shouldn't be valid") t.Error("Tx with multiple identical TxInput shouldn't be valid")
} }
} }

20
client/txgen/main.go
Unescape View File

@ -1,6 +1,7 @@
package main package main
import ( import (
"encoding/binary"
"encoding/hex" "encoding/hex"
"flag" "flag"
"fmt" "fmt"
@ -57,12 +58,13 @@ type TxInfo struct {
// token (1000) to each address in [0 - N). See node.AddTestingAddresses() // token (1000) to each address in [0 - N). See node.AddTestingAddresses()
// //
// Params: // Params:
// subsetId - the which subset of the utxo to work on (used to select addresses)
// shardID - the shardID for current shard // shardID - the shardID for current shard
// dataNodes - nodes containing utxopools of all shards // dataNodes - nodes containing utxopools of all shards
// Returns: // Returns:
// all single-shard txs // all single-shard txs
// all cross-shard txs // all cross-shard txs
func generateSimulatedTransactions(shardID int, dataNodes []*node.Node) ([]*blockchain.Transaction, []*blockchain.Transaction) { func generateSimulatedTransactions(batchCounter, batchNum int, shardID int, dataNodes []*node.Node) ([]*blockchain.Transaction, []*blockchain.Transaction) {
/* /*
UTXO map structure: UTXO map structure:
address - [ address - [
@ -86,6 +88,7 @@ func generateSimulatedTransactions(shardID int, dataNodes []*node.Node) ([]*bloc
UTXOLOOP: UTXOLOOP:
// Loop over all addresses // Loop over all addresses
for address, txMap := range dataNodes[shardID].UtxoPool.UtxoMap { for address, txMap := range dataNodes[shardID].UtxoPool.UtxoMap {
if int(binary.BigEndian.Uint32(address[:]))%batchNum == batchCounter%batchNum { // Work on one subset of utxo at a time
txInfo.address = address txInfo.address = address
// Loop over all txIds for the address // Loop over all txIds for the address
for txIdStr, utxoMap := range txMap { for txIdStr, utxoMap := range txMap {
@ -102,11 +105,8 @@ UTXOLOOP:
txInfo.value = value txInfo.value = value
randNum := rand.Intn(100) randNum := rand.Intn(100)
// 30% sample rate to select UTXO to use for new transactions
if randNum >= 30 { if setting.crossShard && randNum < 0 { // 1/3 cross shard transactions: add another txinput from another shard
continue
}
if setting.crossShard && randNum < 10 { // 1/3 cross shard transactions: add another txinput from another shard
generateCrossShardTx(&txInfo) generateCrossShardTx(&txInfo)
} else { } else {
generateSingleShardTx(&txInfo) generateSingleShardTx(&txInfo)
@ -117,6 +117,7 @@ UTXOLOOP:
} }
} }
} }
}
utxoPoolMutex.Unlock() utxoPoolMutex.Unlock()
log.Debug("[Generator] generated transations", "single-shard", len(txInfo.txs), "cross-shard", len(txInfo.crossTxs)) log.Debug("[Generator] generated transations", "single-shard", len(txInfo.txs), "cross-shard", len(txInfo.crossTxs))
@ -289,6 +290,7 @@ func main() {
// Add it to blockchain // Add it to blockchain
utxoPoolMutex.Lock() utxoPoolMutex.Lock()
node.AddNewBlock(block) node.AddNewBlock(block)
node.UpdateUtxoAndState(block)
utxoPoolMutex.Unlock() utxoPoolMutex.Unlock()
} else { } else {
continue continue
@ -310,6 +312,7 @@ func main() {
start := time.Now() start := time.Now()
totalTime := 60.0 //run for 1 minutes totalTime := 60.0 //run for 1 minutes
batchCounter := 0
for true { for true {
t := time.Now() t := time.Now()
if t.Sub(start).Seconds() >= totalTime { if t.Sub(start).Seconds() >= totalTime {
@ -320,7 +323,7 @@ func main() {
allCrossTxs := []*blockchain.Transaction{} allCrossTxs := []*blockchain.Transaction{}
// Generate simulated transactions // Generate simulated transactions
for i, leader := range leaders { for i, leader := range leaders {
txs, crossTxs := generateSimulatedTransactions(i, nodes) txs, crossTxs := generateSimulatedTransactions(batchCounter, 3, i, nodes)
allCrossTxs = append(allCrossTxs, crossTxs...) allCrossTxs = append(allCrossTxs, crossTxs...)
log.Debug("[Generator] Sending single-shard txs ...", "leader", leader, "numTxs", len(txs), "numCrossTxs", len(crossTxs)) log.Debug("[Generator] Sending single-shard txs ...", "leader", leader, "numTxs", len(txs), "numCrossTxs", len(crossTxs))
@ -344,7 +347,8 @@ func main() {
} }
} }
time.Sleep(500 * time.Millisecond) // Send a batch of transactions periodically time.Sleep(5000 * time.Millisecond) // Send a batch of transactions periodically
batchCounter++
} }
// Send a stop message to stop the nodes at the end // Send a stop message to stop the nodes at the end

3
node/node.go
Unescape View File

@ -53,7 +53,8 @@ func (node *Node) addPendingTransactions(newTxs []*blockchain.Transaction) {
// Note the pending transaction list will then contain the rest of the txs // Note the pending transaction list will then contain the rest of the txs
func (node *Node) getTransactionsForNewBlock(maxNumTxs int) ([]*blockchain.Transaction, []*blockchain.CrossShardTxAndProof) { func (node *Node) getTransactionsForNewBlock(maxNumTxs int) ([]*blockchain.Transaction, []*blockchain.CrossShardTxAndProof) {
node.pendingTxMutex.Lock() node.pendingTxMutex.Lock()
selected, unselected, crossShardTxs := node.UtxoPool.SelectTransactionsForNewBlock(node.pendingTransactions, maxNumTxs) selected, unselected, invalid, crossShardTxs := node.UtxoPool.SelectTransactionsForNewBlock(node.pendingTransactions, maxNumTxs)
_ = invalid // invalid txs are discard
node.pendingTransactions = unselected node.pendingTransactions = unselected
node.pendingTxMutex.Unlock() node.pendingTxMutex.Unlock()
return selected, crossShardTxs return selected, crossShardTxs

4
node/node_handler.go
Unescape View File

@ -18,9 +18,9 @@ import (
const ( const (
// The max number of transaction per a block. // The max number of transaction per a block.
MaxNumberOfTransactionsPerBlock = 3000 MaxNumberOfTransactionsPerBlock = 10000
// The number of blocks allowed before generating state block // The number of blocks allowed before generating state block
NumBlocksBeforeStateBlock = 10 NumBlocksBeforeStateBlock = 100
) )
// NodeHandler handles a new incoming connection. // NodeHandler handles a new incoming connection.

Write Preview
Loading…
Cancel
Save