github.com/igggame/nebulas-go@v2.1.0+incompatible/consensus/dpos/dpos_test.go

// Copyright (C) 2017 go-nebulas authors
//
// This file is part of the go-nebulas library.
//
// the go-nebulas library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// the go-nebulas library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with the go-nebulas library.  If not, see <http://www.gnu.org/licenses/>.
//

package dpos

import (
	"os"
	"runtime"
	"testing"

	"github.com/gogo/protobuf/proto"

	"github.com/nebulasio/go-nebulas/util"

	"time"

	"github.com/nebulasio/go-nebulas/account"
	"github.com/nebulasio/go-nebulas/core"
	"github.com/nebulasio/go-nebulas/crypto/keystore"
	"github.com/stretchr/testify/assert"
)

var (
	DefaultOpenDynasty = core.NewMockNeb(nil, nil, nil).Genesis().Consensus.Dpos.Dynasty
)

func mockBlockFromNetwork(block *core.Block) (*core.Block, error) {
	pbBlock, err := block.ToProto()
	if err != nil {
		return nil, err
	}
	bytes, err := proto.Marshal(pbBlock)
	if err := proto.Unmarshal(bytes, pbBlock); err != nil {
		return nil, err
	}
	block = new(core.Block)
	block.FromProto(pbBlock)
	return block, nil
}

func mockNeb(t *testing.T) *core.MockNeb {
	consensus := NewDpos()
	am, err := account.NewManager(nil)
	assert.Nil(t, err)
	neb := core.NewMockNeb(am, consensus, nil)
	return neb
}

func TestDpos_New(t *testing.T) {
	neb := mockNeb(t)
	coinbase := neb.Config().Chain.Coinbase
	neb.Config().Chain.Coinbase += "0"
	assert.NotNil(t, neb.Consensus().Setup(neb))
	neb.Config().Chain.Coinbase = coinbase
	neb.Config().Chain.Miner += "0"
	assert.NotNil(t, neb.Consensus().Setup(neb))
}

func TestDpos_VerifySign(t *testing.T) {
	neb := mockNeb(t)
	tail := neb.BlockChain().TailBlock()

	elapsedSecondInMs := int64(DynastySize*BlockIntervalInMs + DynastyIntervalInMs)
	consensusState, err := tail.WorldState().NextConsensusState(elapsedSecondInMs / SecondInMs)
	assert.Nil(t, err)
	coinbase, err := core.AddressParse("n1FF1nz6tarkDVwWQkMnnwFPuPKUaQTdptE")
	assert.Nil(t, err)
	block, err := core.NewBlock(neb.BlockChain().ChainID(), coinbase, tail)
	assert.Nil(t, err)
	block.SetTimestamp((DynastySize*BlockIntervalInMs + DynastyIntervalInMs) / SecondInMs)
	block.WorldState().SetConsensusState(consensusState)
	block.Seal()
	manager, _ := account.NewManager(nil)
	miner, err := core.AddressParse("n1GmkKH6nBMw4rrjt16RrJ9WcgvKUtAZP1s")
	assert.Nil(t, err)
	assert.Nil(t, manager.Unlock(miner, []byte("passphrase"), keystore.DefaultUnlockDuration))
	assert.Nil(t, manager.SignBlock(miner, block))
	assert.Equal(t, neb.Consensus().VerifyBlock(block), ErrInvalidBlockProposer)
}

func GetUnlockAddress(t *testing.T, am core.AccountManager, addr string) *core.Address {
	address, err := core.AddressParse(addr)
	assert.Nil(t, err)
	assert.Nil(t, am.Unlock(address, []byte("passphrase"), time.Second*60*60*24*365))
	return address
}

func TestForkChoice(t *testing.T) {
	neb := mockNeb(t)
	am, _ := account.NewManager(neb)

	/*
		genesis -- 0 -- 11 -- 111 -- 1111
					 \_ 12 -- 221
	*/

	addr0 := GetUnlockAddress(t, am, "n1GmkKH6nBMw4rrjt16RrJ9WcgvKUtAZP1s")
	block0, _ := neb.BlockChain().NewBlock(addr0)
	block0.SetTimestamp(BlockIntervalInMs / SecondInMs)
	consensusState, err := neb.BlockChain().TailBlock().WorldState().NextConsensusState(BlockIntervalInMs / SecondInMs)
	assert.Nil(t, err)
	block0.WorldState().SetConsensusState(consensusState)
	block0.Seal()
	am.SignBlock(addr0, block0)
	assert.Nil(t, neb.BlockChain().BlockPool().Push(block0))
	assert.Equal(t, len(neb.BlockChain().DetachedTailBlocks()), 1)
	assert.Equal(t, block0.Hash(), neb.BlockChain().TailBlock().Hash())

	addr1 := GetUnlockAddress(t, am, "n1H4MYms9F55ehcvygwWE71J8tJC4CRr2so")
	block11, err := neb.BlockChain().NewBlock(addr1)
	assert.Nil(t, err)
	consensusState, err = neb.BlockChain().TailBlock().WorldState().NextConsensusState(BlockIntervalInMs / SecondInMs)
	assert.Nil(t, err)
	block11.WorldState().SetConsensusState(consensusState)
	block11.SetTimestamp((BlockIntervalInMs * 2) / SecondInMs)
	block11.Seal()
	am.SignBlock(addr1, block11)

	addr2 := GetUnlockAddress(t, am, "n1JAy4X6KKLCNiTd7MWMRsVBjgdVq5WCCpf")
	block12, err := neb.BlockChain().NewBlock(addr2)
	assert.Nil(t, err)
	consensusState, err = neb.BlockChain().TailBlock().WorldState().NextConsensusState(BlockIntervalInMs * 2 / SecondInMs)
	assert.Nil(t, err)
	block12.WorldState().SetConsensusState(consensusState)
	block12.SetTimestamp(BlockIntervalInMs * 3 / SecondInMs)
	block12.Seal()
	am.SignBlock(addr2, block12)

	assert.Nil(t, neb.BlockChain().BlockPool().Push(block11))
	assert.Equal(t, len(neb.BlockChain().DetachedTailBlocks()), 1)
	assert.Equal(t, block11.Hash(), neb.BlockChain().TailBlock().Hash())

	assert.Nil(t, neb.BlockChain().BlockPool().Push(block12))
	assert.Equal(t, len(neb.BlockChain().DetachedTailBlocks()), 2)
	tail := block11.Hash()
	if less(block11, block12) {
		tail = block12.Hash()
	}
	assert.Equal(t, neb.BlockChain().TailBlock().Hash(), tail)

	addr3 := GetUnlockAddress(t, am, "n1LkDi2gGMqPrjYcczUiweyP4RxTB6Go1qS")
	block111, err := neb.BlockChain().NewBlock(addr3)
	assert.Nil(t, err)
	consensusState, err = neb.BlockChain().TailBlock().WorldState().NextConsensusState(BlockIntervalInMs * 2 / SecondInMs)
	assert.Nil(t, err)
	block111.WorldState().SetConsensusState(consensusState)
	block111.SetTimestamp(BlockIntervalInMs * 4 / SecondInMs)
	block111.Seal()
	am.SignBlock(addr3, block111)
	assert.Equal(t, len(neb.BlockChain().DetachedTailBlocks()), 2)
	assert.Nil(t, neb.BlockChain().BlockPool().Push(block111))

}

func TestCanMining(t *testing.T) {
	neb := mockNeb(t)
	assert.Equal(t, neb.Consensus().Pending(), true)
	neb.Consensus().SuspendMining()
	assert.Equal(t, neb.Consensus().Pending(), true)
	neb.Consensus().ResumeMining()
	assert.Equal(t, neb.Consensus().Pending(), false)
}

func TestVerifyBlock(t *testing.T) {
	neb := mockNeb(t)
	dpos := neb.Consensus()
	tail := neb.BlockChain().TailBlock()

	coinbase, err := core.AddressParse("n1FF1nz6tarkDVwWQkMnnwFPuPKUaQTdptE")
	assert.Nil(t, err)
	manager, _ := account.NewManager(neb)
	assert.Nil(t, dpos.EnableMining("passphrase"))

	elapsedSecond := DynastyIntervalInMs / SecondInMs
	consensusState, err := tail.WorldState().NextConsensusState(elapsedSecond)
	assert.Nil(t, err)
	block, err := core.NewBlock(neb.BlockChain().ChainID(), coinbase, tail)
	block.SetTimestamp(tail.Timestamp() + 1)
	assert.Nil(t, err)
	block.WorldState().SetConsensusState(consensusState)
	block.Seal()
	assert.Nil(t, manager.Unlock(coinbase, []byte("passphrase"), keystore.DefaultUnlockDuration))
	assert.Nil(t, manager.SignBlock(coinbase, block))

	assert.NotNil(t, dpos.VerifyBlock(block), ErrInvalidBlockInterval)

	elapsedSecond = DynastyIntervalInMs / SecondInMs
	consensusState, err = tail.WorldState().NextConsensusState(elapsedSecond)
	block, err = core.NewBlock(neb.BlockChain().ChainID(), coinbase, tail)
	assert.Nil(t, err)
	block.WorldState().SetConsensusState(consensusState)
	block.SetTimestamp(tail.Timestamp() + elapsedSecond)
	block.Seal()
	assert.Nil(t, manager.SignBlock(coinbase, block))
	assert.Nil(t, dpos.VerifyBlock(block))

	elapsedSecond = (DynastySize*BlockIntervalInMs + DynastyIntervalInMs) / SecondInMs
	consensusState, err = tail.WorldState().NextConsensusState(elapsedSecond)
	block, err = core.NewBlock(neb.BlockChain().ChainID(), coinbase, tail)
	assert.Nil(t, err)
	block.WorldState().SetConsensusState(consensusState)
	block.SetTimestamp(tail.Timestamp() + elapsedSecond)
	block.Seal()
	assert.Nil(t, manager.SignBlock(coinbase, block))
	assert.Nil(t, dpos.VerifyBlock(block))
}

func TestDpos_MintBlock(t *testing.T) {
	neb := mockNeb(t)
	dpos := neb.Consensus().(*Dpos)

	assert.Equal(t, dpos.mintBlock(0), ErrCannotMintWhenDisable)

	assert.Nil(t, dpos.EnableMining("passphrase"))
	dpos.SuspendMining()
	assert.Equal(t, dpos.mintBlock(0), ErrCannotMintWhenPending)
	dpos.ResumeMining()
	assert.Equal(t, dpos.mintBlock(BlockIntervalInMs/SecondInMs), ErrInvalidBlockProposer)

	//received := []byte{}
	assert.Equal(t, dpos.mintBlock(DynastyIntervalInMs/SecondInMs), nil)
	//assert.NotEqual(t, received, []byte{})
}

func TestDposContracts(t *testing.T) {
	// change cwd make lib accessible.
	os.Chdir("../../")
	runtime.GOMAXPROCS(runtime.NumCPU())
	neb := mockNeb(t)
	tail := neb.BlockChain().TailBlock()
	dpos := neb.Consensus()

	manager, _ := account.NewManager(neb)
	assert.Nil(t, dpos.EnableMining("passphrase"))

	a, _ := core.AddressParse("n1FF1nz6tarkDVwWQkMnnwFPuPKUaQTdptE")
	assert.Nil(t, manager.Unlock(a, []byte("passphrase"), keystore.YearUnlockDuration))
	b, _ := core.AddressParse("n1GmkKH6nBMw4rrjt16RrJ9WcgvKUtAZP1s")
	assert.Nil(t, manager.Unlock(b, []byte("passphrase"), keystore.YearUnlockDuration))
	c, _ := core.AddressParse("n1H4MYms9F55ehcvygwWE71J8tJC4CRr2so")
	assert.Nil(t, manager.Unlock(c, []byte("passphrase"), keystore.YearUnlockDuration))
	d, _ := core.AddressParse("n1JAy4X6KKLCNiTd7MWMRsVBjgdVq5WCCpf")
	assert.Nil(t, manager.Unlock(d, []byte("passphrase"), keystore.YearUnlockDuration))
	e, _ := core.AddressParse("n1LkDi2gGMqPrjYcczUiweyP4RxTB6Go1qS")
	assert.Nil(t, manager.Unlock(e, []byte("passphrase"), keystore.YearUnlockDuration))
	f, _ := core.AddressParse("n1LmP9K8pFF33fgdgHZonFEMsqZinJ4EUqk")
	assert.Nil(t, manager.Unlock(f, []byte("passphrase"), keystore.YearUnlockDuration))

	elapsedSecond := BlockIntervalInMs / SecondInMs
	consensusState, err := tail.WorldState().NextConsensusState(elapsedSecond)
	assert.Nil(t, err)
	block, err := core.NewBlock(neb.BlockChain().ChainID(), b, tail)
	assert.Nil(t, err)
	block.WorldState().SetConsensusState(consensusState)
	block.SetTimestamp(consensusState.TimeStamp())

	source := `"use strict";var DepositeContent=function(text){if(text){var o=JSON.parse(text);this.balance=new BigNumber(o.balance);this.expiryHeight=new BigNumber(o.expiryHeight)}else{this.balance=new BigNumber(0);this.expiryHeight=new BigNumber(0)}};DepositeContent.prototype={toString:function(){return JSON.stringify(this)}};var BankVaultContract=function(){LocalContractStorage.defineMapProperty(this,"bankVault",{parse:function(text){return new DepositeContent(text)},stringify:function(o){return o.toString()}})};BankVaultContract.prototype={init:function(){},save:function(height){var from=Blockchain.transaction.from;var value=Blockchain.transaction.value;var bk_height=new BigNumber(Blockchain.block.height);var orig_deposit=this.bankVault.get(from);if(orig_deposit){value=value.plus(orig_deposit.balance)}var deposit=new DepositeContent();deposit.balance=value;deposit.expiryHeight=bk_height.plus(height);this.bankVault.put(from,deposit)},takeout:function(value){var from=Blockchain.transaction.from;var bk_height=new BigNumber(Blockchain.block.height);var amount=new BigNumber(value);var deposit=this.bankVault.get(from);if(!deposit){throw new Error("No deposit before.")}if(bk_height.lt(deposit.expiryHeight)){throw new Error("Can not takeout before expiryHeight.")}if(amount.gt(deposit.balance)){throw new Error("Insufficient balance.")}var result=Blockchain.transfer(from,amount);if(result!=0){throw new Error("transfer failed.")}Event.Trigger("BankVault",{Transfer:{from:Blockchain.transaction.to,to:from,value:amount.toString()}});deposit.balance=deposit.balance.sub(amount);this.bankVault.put(from,deposit)},balanceOf:function(){var from=Blockchain.transaction.from;return this.bankVault.get(from)}};module.exports=BankVaultContract;`
	sourceType := "js"
	argsDeploy := ""
	deploy, _ := core.NewDeployPayload(source, sourceType, argsDeploy)
	payloadDeploy, _ := deploy.ToBytes()

	j := 2

	for i := 1; i < j; i++ {
		value, _ := util.NewUint128FromInt(1)
		gasLimit, _ := util.NewUint128FromInt(200000)
		txDeploy, _ := core.NewTransaction(neb.BlockChain().ChainID(), a, a, value, uint64(i), core.TxPayloadDeployType, payloadDeploy, core.TransactionGasPrice, gasLimit)
		assert.Nil(t, manager.SignTransaction(a, txDeploy))
		assert.Nil(t, neb.BlockChain().TransactionPool().Push(txDeploy))

		txDeploy, _ = core.NewTransaction(neb.BlockChain().ChainID(), b, b, value, uint64(i), core.TxPayloadDeployType, payloadDeploy, core.TransactionGasPrice, gasLimit)
		assert.Nil(t, manager.SignTransaction(b, txDeploy))
		assert.Nil(t, neb.BlockChain().TransactionPool().Push(txDeploy))

		txDeploy, _ = core.NewTransaction(neb.BlockChain().ChainID(), c, c, value, uint64(i), core.TxPayloadDeployType, payloadDeploy, core.TransactionGasPrice, gasLimit)
		assert.Nil(t, manager.SignTransaction(c, txDeploy))
		assert.Nil(t, neb.BlockChain().TransactionPool().Push(txDeploy))

		txDeploy, _ = core.NewTransaction(neb.BlockChain().ChainID(), d, d, value, uint64(i), core.TxPayloadDeployType, payloadDeploy, core.TransactionGasPrice, gasLimit)
		assert.Nil(t, manager.SignTransaction(d, txDeploy))
		assert.Nil(t, neb.BlockChain().TransactionPool().Push(txDeploy))
	}

	block.CollectTransactions((time.Now().Unix() + 1) * SecondInMs)
	assert.Equal(t, 4*(j-1), len(block.Transactions()))
	assert.Nil(t, block.Seal())
	assert.Nil(t, manager.SignBlock(b, block))
	assert.Nil(t, neb.BlockChain().BlockPool().Push(block))

	assert.Equal(t, block.Hash(), neb.BlockChain().TailBlock().Hash())
}

func testMintBlock(t *testing.T, round int, neb core.Neblet, num int) {
	manager, _ := account.NewManager(neb)

	a, _ := core.AddressParse("n1FF1nz6tarkDVwWQkMnnwFPuPKUaQTdptE")
	assert.Nil(t, manager.Unlock(a, []byte("passphrase"), keystore.YearUnlockDuration))
	b, _ := core.AddressParse("n1GmkKH6nBMw4rrjt16RrJ9WcgvKUtAZP1s")
	assert.Nil(t, manager.Unlock(b, []byte("passphrase"), keystore.YearUnlockDuration))
	c, _ := core.AddressParse("n1H4MYms9F55ehcvygwWE71J8tJC4CRr2so")
	assert.Nil(t, manager.Unlock(c, []byte("passphrase"), keystore.YearUnlockDuration))
	d, _ := core.AddressParse("n1JAy4X6KKLCNiTd7MWMRsVBjgdVq5WCCpf")
	assert.Nil(t, manager.Unlock(d, []byte("passphrase"), keystore.YearUnlockDuration))
	e, _ := core.AddressParse("n1LkDi2gGMqPrjYcczUiweyP4RxTB6Go1qS")
	assert.Nil(t, manager.Unlock(e, []byte("passphrase"), keystore.YearUnlockDuration))
	f, _ := core.AddressParse("n1LmP9K8pFF33fgdgHZonFEMsqZinJ4EUqk")
	assert.Nil(t, manager.Unlock(f, []byte("passphrase"), keystore.YearUnlockDuration))

	elapsedSecond := int64(BlockIntervalInMs / SecondInMs)
	consensusState, err := neb.BlockChain().TailBlock().WorldState().NextConsensusState(elapsedSecond)
	assert.Nil(t, err)

	coinbases := []*core.Address{a, b, c, d, e, f}
	coinbase := coinbases[(round+1)%len(coinbases)]
	block, err := core.NewBlock(neb.BlockChain().ChainID(), coinbase, neb.BlockChain().TailBlock())
	assert.Nil(t, err)
	block.WorldState().SetConsensusState(consensusState)
	block.SetTimestamp(consensusState.TimeStamp())
	acc, _ := block.WorldState().GetOrCreateUserAccount(a.Bytes())
	nonce := int(acc.Nonce())

	for i := 1; i < num; i++ {
		gas, _ := util.NewUint128FromInt(1000000)
		limit, _ := util.NewUint128FromInt(200000)
		tx, _ := core.NewTransaction(neb.BlockChain().ChainID(), a, b, util.NewUint128(), uint64(nonce+4*i-3), core.TxPayloadBinaryType, []byte("nas"), gas, limit)
		assert.Nil(t, manager.SignTransaction(a, tx))
		assert.Nil(t, neb.BlockChain().TransactionPool().Push(tx))

		tx, _ = core.NewTransaction(neb.BlockChain().ChainID(), a, c, util.NewUint128(), uint64(nonce+4*i-2), core.TxPayloadBinaryType, []byte("nas"), gas, limit)
		assert.Nil(t, manager.SignTransaction(a, tx))
		assert.Nil(t, neb.BlockChain().TransactionPool().Push(tx))

		tx, _ = core.NewTransaction(neb.BlockChain().ChainID(), a, d, util.NewUint128(), uint64(nonce+4*i-1), core.TxPayloadBinaryType, []byte("nas"), gas, limit)
		assert.Nil(t, manager.SignTransaction(a, tx))
		assert.Nil(t, neb.BlockChain().TransactionPool().Push(tx))

		tx, _ = core.NewTransaction(neb.BlockChain().ChainID(), a, e, util.NewUint128(), uint64(nonce+4*i), core.TxPayloadBinaryType, []byte("nas"), gas, limit)
		assert.Nil(t, manager.SignTransaction(a, tx))
		assert.Nil(t, neb.BlockChain().TransactionPool().Push(tx))

		tx, _ = core.NewTransaction(neb.BlockChain().ChainID(), b, f, util.NewUint128(), uint64(i), core.TxPayloadBinaryType, []byte("nas"), gas, limit)
		assert.Nil(t, manager.SignTransaction(b, tx))
		assert.Nil(t, neb.BlockChain().TransactionPool().Push(tx))

		tx, _ = core.NewTransaction(neb.BlockChain().ChainID(), c, f, util.NewUint128(), uint64(i), core.TxPayloadBinaryType, []byte("nas"), gas, limit)
		assert.Nil(t, manager.SignTransaction(c, tx))
		assert.Nil(t, neb.BlockChain().TransactionPool().Push(tx))

		tx, _ = core.NewTransaction(neb.BlockChain().ChainID(), d, f, util.NewUint128(), uint64(i), core.TxPayloadBinaryType, []byte("nas"), gas, limit)
		assert.Nil(t, manager.SignTransaction(d, tx))
		assert.Nil(t, neb.BlockChain().TransactionPool().Push(tx))
	}

	block.CollectTransactions((time.Now().Unix() + 1) * SecondInMs)
	assert.Equal(t, 7*(num-1), len(block.Transactions()))
	assert.Nil(t, block.Seal())
	assert.Nil(t, manager.SignBlock(coinbase, block))
	assert.Nil(t, neb.BlockChain().BlockPool().Push(block))

	assert.Equal(t, block.Hash(), neb.BlockChain().TailBlock().Hash())
}

func TestDposTxBinary(t *testing.T) {
	runtime.GOMAXPROCS(runtime.NumCPU())

	neb := mockNeb(t)

	for i := 0; i < 1; i++ {
		testMintBlock(t, i, neb, 5)
	}

	return
}

func TestDoubleMint(t *testing.T) {
	neb := mockNeb(t)
	chain := neb.BlockChain()
	am := neb.AccountManager()

	addr0 := GetUnlockAddress(t, am, "n1GmkKH6nBMw4rrjt16RrJ9WcgvKUtAZP1s")

	block0, _ := chain.NewBlock(addr0)
	consensusState, err := chain.TailBlock().WorldState().NextConsensusState(BlockIntervalInMs / SecondInMs)
	assert.Nil(t, err)
	block0.SetTimestamp(chain.TailBlock().Timestamp() + BlockIntervalInMs/SecondInMs)
	block0.WorldState().SetConsensusState(consensusState)
	block0.Seal()
	am.SignBlock(addr0, block0)

	assert.Nil(t, chain.BlockPool().Push(block0))
	assert.Equal(t, block0.Hash(), chain.TailBlock().Hash())

	consensusState, err = chain.TailBlock().WorldState().NextConsensusState(0)
	assert.Equal(t, err, ErrNotBlockForgTime)
}