package dex import ( "crypto/ecdsa" "fmt" "math/big" "strings" "testing" "time" coreCommon "github.com/dexon-foundation/dexon-consensus/common" coreTypes "github.com/dexon-foundation/dexon-consensus/core/types" "github.com/dexon-foundation/dexon/accounts/abi" "github.com/dexon-foundation/dexon/common" "github.com/dexon-foundation/dexon/consensus/dexcon" "github.com/dexon-foundation/dexon/core" "github.com/dexon-foundation/dexon/core/types" "github.com/dexon-foundation/dexon/core/vm" "github.com/dexon-foundation/dexon/crypto" "github.com/dexon-foundation/dexon/ethdb" "github.com/dexon-foundation/dexon/params" "github.com/dexon-foundation/dexon/rlp" ) func TestPreparePayload(t *testing.T) { key, err := crypto.GenerateKey() if err != nil { t.Fatalf("hex to ecdsa error: %v", err) } dex, err := newTestDexonWithGenesis(key) if err != nil { t.Fatalf("new test dexon error: %v", err) } signer := types.NewEIP155Signer(dex.chainConfig.ChainID) var expectTx types.Transactions for i := 0; i < 5; i++ { tx, err := addTx(dex, i, signer, key) if err != nil { t.Fatalf("add tx error: %v", err) } expectTx = append(expectTx, tx) } // This transaction will not be included. _, err = addTx(dex, 100, signer, key) if err != nil { t.Fatalf("add tx error: %v", err) } chainID := new(big.Int).Mod(crypto.PubkeyToAddress(key.PublicKey).Big(), big.NewInt(int64(dex.chainConfig.Dexcon.NumChains))) var chainNum uint32 for chainNum = 0; chainNum < dex.chainConfig.Dexcon.NumChains; chainNum++ { root := dex.blockchain.CurrentBlock().Root() dex.app.chainRoot.Store(chainNum, &root) payload, err := dex.app.PreparePayload(coreTypes.Position{ChainID: chainNum}) if err != nil { t.Fatalf("prepare payload error: %v", err) } var transactions types.Transactions err = rlp.DecodeBytes(payload, &transactions) if err != nil { t.Fatalf("rlp decode error: %v", err) } // Only one chain id allow prepare transactions. if chainID.Uint64() == uint64(chainNum) && len(transactions) != 5 { t.Fatalf("incorrect transaction num expect %v but %v", 5, len(transactions)) } else if chainID.Uint64() != uint64(chainNum) && len(transactions) != 0 { t.Fatalf("expect empty slice but %v", len(transactions)) } for i, tx := range transactions { if expectTx[i].Gas() != tx.Gas() { t.Fatalf("unexpected gas expect %v but %v", expectTx[i].Gas(), tx.Gas()) } if expectTx[i].Hash() != tx.Hash() { t.Fatalf("unexpected hash expect %v but %v", expectTx[i].Hash(), tx.Hash()) } if expectTx[i].Nonce() != tx.Nonce() { t.Fatalf("unexpected nonce expect %v but %v", expectTx[i].Nonce(), tx.Nonce()) } if expectTx[i].GasPrice().Uint64() != tx.GasPrice().Uint64() { t.Fatalf("unexpected gas price expect %v but %v", expectTx[i].GasPrice().Uint64(), tx.GasPrice().Uint64()) } } } } func TestPrepareWitness(t *testing.T) { key, err := crypto.GenerateKey() if err != nil { t.Fatalf("hex to ecdsa error: %v", err) } dex, err := newTestDexonWithGenesis(key) if err != nil { t.Fatalf("new test dexon error: %v", err) } currentBlock := dex.blockchain.CurrentBlock() witness, err := dex.app.PrepareWitness(0) if err != nil { t.Fatalf("prepare witness error: %v", err) } if witness.Height != currentBlock.NumberU64() { t.Fatalf("unexpeted witness height %v", witness.Height) } var witnessData types.WitnessData err = rlp.DecodeBytes(witness.Data, &witnessData) if err != nil { t.Fatalf("rlp decode error: %v", err) } if witnessData.Root != currentBlock.Root() { t.Fatalf("expect root %v but %v", currentBlock.Root(), witnessData.Root) } if witnessData.ReceiptHash != currentBlock.ReceiptHash() { t.Fatalf("expect receipt hash %v but %v", currentBlock.ReceiptHash(), witnessData.ReceiptHash) } if _, err := dex.app.PrepareWitness(999); err == nil { t.Fatalf("it must be get error from prepare") } else { t.Logf("Nice error: %v", err) } } func TestVerifyBlock(t *testing.T) { key, err := crypto.GenerateKey() if err != nil { t.Fatalf("hex to ecdsa error: %v", err) } dex, err := newTestDexonWithGenesis(key) if err != nil { t.Fatalf("new test dexon error: %v", err) } chainID := new(big.Int).Mod(crypto.PubkeyToAddress(key.PublicKey).Big(), big.NewInt(int64(dex.chainConfig.Dexcon.NumChains))) root := dex.blockchain.CurrentBlock().Root() dex.app.chainRoot.Store(uint32(chainID.Uint64()), &root) // Prepare first confirmed block. _, err = prepareConfirmedBlocks(dex, []*ecdsa.PrivateKey{key}, 0) if err != nil { t.Fatalf("prepare confirmed blocks error: %v", err) } // Prepare normal block. block := &coreTypes.Block{} block.Hash = coreCommon.NewRandomHash() block.Position.ChainID = uint32(chainID.Uint64()) block.Position.Height = 1 block.ProposerID = coreTypes.NodeID{coreCommon.Hash{1, 2, 3}} block.Payload, block.Witness, err = prepareDataWithoutTxPool(dex, key, 0, 100) if err != nil { t.Fatalf("prepare data error: %v", err) } // Expect ok. status := dex.app.VerifyBlock(block) if status != coreTypes.VerifyOK { t.Fatalf("verify fail: %v", status) } // Prepare invalid nonce tx. block = &coreTypes.Block{} block.Hash = coreCommon.NewRandomHash() block.Position.ChainID = uint32(chainID.Uint64()) block.Position.Height = 1 block.ProposerID = coreTypes.NodeID{coreCommon.Hash{1, 2, 3}} block.Payload, block.Witness, err = prepareDataWithoutTxPool(dex, key, 1, 100) if err != nil { t.Fatalf("prepare data error: %v", err) } // Expect invalid block. status = dex.app.VerifyBlock(block) if status != coreTypes.VerifyInvalidBlock { t.Fatalf("verify fail: %v", status) } // Prepare invalid block height. block = &coreTypes.Block{} block.Hash = coreCommon.NewRandomHash() block.Position.ChainID = uint32(chainID.Uint64()) block.Position.Height = 2 block.ProposerID = coreTypes.NodeID{coreCommon.Hash{1, 2, 3}} block.Payload, block.Witness, err = prepareDataWithoutTxPool(dex, key, 0, 100) if err != nil { t.Fatalf("prepare data error: %v", err) } // Expect retry later. status = dex.app.VerifyBlock(block) if status != coreTypes.VerifyRetryLater { t.Fatalf("verify fail expect retry later but get %v", status) } // Prepare reach block limit. block = &coreTypes.Block{} block.Hash = coreCommon.NewRandomHash() block.Position.ChainID = uint32(chainID.Uint64()) block.Position.Height = 1 block.ProposerID = coreTypes.NodeID{coreCommon.Hash{1, 2, 3}} block.Payload, block.Witness, err = prepareDataWithoutTxPool(dex, key, 0, 10000) if err != nil { t.Fatalf("prepare data error: %v", err) } // Expect invalid block. status = dex.app.VerifyBlock(block) if status != coreTypes.VerifyInvalidBlock { t.Fatalf("verify fail expect invalid block but get %v", status) } // Prepare insufficient funds. block = &coreTypes.Block{} block.Hash = coreCommon.NewRandomHash() block.Position.ChainID = uint32(chainID.Uint64()) block.Position.Height = 1 block.ProposerID = coreTypes.NodeID{coreCommon.Hash{1, 2, 3}} _, block.Witness, err = prepareDataWithoutTxPool(dex, key, 0, 0) if err != nil { t.Fatalf("prepare data error: %v", err) } signer := types.NewEIP155Signer(dex.chainConfig.ChainID) tx := types.NewTransaction( 0, common.BytesToAddress([]byte{9}), big.NewInt(50000000000000001), params.TxGas, big.NewInt(1), nil) tx, err = types.SignTx(tx, signer, key) if err != nil { return } block.Payload, err = rlp.EncodeToBytes(types.Transactions{tx}) if err != nil { return } // expect invalid block status = dex.app.VerifyBlock(block) if status != coreTypes.VerifyInvalidBlock { t.Fatalf("verify fail expect invalid block but get %v", status) } // Prepare invalid intrinsic gas. block = &coreTypes.Block{} block.Hash = coreCommon.NewRandomHash() block.Position.ChainID = uint32(chainID.Uint64()) block.Position.Height = 1 block.ProposerID = coreTypes.NodeID{coreCommon.Hash{1, 2, 3}} _, block.Witness, err = prepareDataWithoutTxPool(dex, key, 0, 0) if err != nil { t.Fatalf("prepare data error: %v", err) } signer = types.NewEIP155Signer(dex.chainConfig.ChainID) tx = types.NewTransaction( 0, common.BytesToAddress([]byte{9}), big.NewInt(1), params.TxGas, big.NewInt(1), make([]byte, 1)) tx, err = types.SignTx(tx, signer, key) if err != nil { return } block.Payload, err = rlp.EncodeToBytes(types.Transactions{tx}) if err != nil { return } // Expect invalid block. status = dex.app.VerifyBlock(block) if status != coreTypes.VerifyInvalidBlock { t.Fatalf("verify fail expect invalid block but get %v", status) } // Prepare invalid transactions with nonce. block = &coreTypes.Block{} block.Hash = coreCommon.NewRandomHash() block.Position.ChainID = uint32(chainID.Uint64()) block.Position.Height = 1 block.ProposerID = coreTypes.NodeID{coreCommon.Hash{1, 2, 3}} _, block.Witness, err = prepareDataWithoutTxPool(dex, key, 0, 0) if err != nil { t.Fatalf("prepare data error: %v", err) } signer = types.NewEIP155Signer(dex.chainConfig.ChainID) tx1 := types.NewTransaction( 0, common.BytesToAddress([]byte{9}), big.NewInt(1), params.TxGas, big.NewInt(1), make([]byte, 1)) tx1, err = types.SignTx(tx, signer, key) if err != nil { return } // Invalid nonce. tx2 := types.NewTransaction( 2, common.BytesToAddress([]byte{9}), big.NewInt(1), params.TxGas, big.NewInt(1), make([]byte, 1)) tx2, err = types.SignTx(tx, signer, key) if err != nil { return } block.Payload, err = rlp.EncodeToBytes(types.Transactions{tx1, tx2}) if err != nil { return } // Expect invalid block. status = dex.app.VerifyBlock(block) if status != coreTypes.VerifyInvalidBlock { t.Fatalf("verify fail expect invalid block but get %v", status) } } func TestBlockConfirmed(t *testing.T) { key, err := crypto.GenerateKey() if err != nil { t.Fatalf("hex to ecdsa error: %v", err) } dex, err := newTestDexonWithGenesis(key) if err != nil { t.Fatalf("new test dexon error: %v", err) } chainID := new(big.Int).Mod(crypto.PubkeyToAddress(key.PublicKey).Big(), big.NewInt(int64(dex.chainConfig.Dexcon.NumChains))) root := dex.blockchain.CurrentBlock().Root() dex.app.chainRoot.Store(uint32(chainID.Uint64()), &root) var ( expectCost big.Int expectNonce uint64 expectCounter uint64 ) for i := 0; i < 10; i++ { var startNonce int if expectNonce != 0 { startNonce = int(expectNonce) + 1 } payload, witness, cost, nonce, err := prepareData(dex, key, startNonce, 50) if err != nil { t.Fatalf("prepare data error: %v", err) } expectCost.Add(&expectCost, &cost) expectNonce = nonce block := &coreTypes.Block{} block.Hash = coreCommon.NewRandomHash() block.Witness = witness block.Payload = payload block.ProposerID = coreTypes.NodeID{coreCommon.Hash{1, 2, 3}} block.Position.ChainID = uint32(chainID.Uint64()) dex.app.BlockConfirmed(*block) expectCounter++ } info := dex.app.blockchain.GetAddressInfo(uint32(chainID.Uint64()), crypto.PubkeyToAddress(key.PublicKey)) if info.Counter != expectCounter { t.Fatalf("expect address counter is %v but %v", expectCounter, info.Counter) } if info.Cost.Cmp(&expectCost) != 0 { t.Fatalf("expect address cost is %v but %v", expectCost.Uint64(), info.Cost.Uint64()) } if info.Nonce != expectNonce { t.Fatalf("expect address nonce is %v but %v", expectNonce, info.Nonce) } } func TestBlockDelivered(t *testing.T) { key, err := crypto.GenerateKey() if err != nil { t.Fatalf("hex to ecdsa error: %v", err) } dex, err := newTestDexonWithGenesis(key) if err != nil { t.Fatalf("new test dexon error: %v", err) } chainID := new(big.Int).Mod(crypto.PubkeyToAddress(key.PublicKey).Big(), big.NewInt(int64(dex.chainConfig.Dexcon.NumChains))) root := dex.blockchain.CurrentBlock().Root() dex.app.chainRoot.Store(uint32(chainID.Uint64()), &root) address := crypto.PubkeyToAddress(key.PublicKey) firstBlocksInfo, err := prepareConfirmedBlocks(dex, []*ecdsa.PrivateKey{key}, 50) if err != nil { t.Fatalf("preapare confirmed block error: %v", err) } dex.app.BlockDelivered(firstBlocksInfo[0].Block.Hash, firstBlocksInfo[0].Block.Position, coreTypes.FinalizationResult{ Timestamp: time.Now(), Height: 1, }) currentState, err := dex.blockchain.State() if err != nil { t.Fatalf("get state error: %v", err) } currentBlock := dex.blockchain.CurrentBlock() if currentBlock.NumberU64() != 1 { t.Fatalf("unexpected current block number %v", currentBlock.NumberU64()) } currentNonce := currentState.GetNonce(address) if currentNonce != firstBlocksInfo[0].Nonce+1 { t.Fatalf("unexpected pending state nonce %v", currentNonce) } balance := currentState.GetBalance(address) if new(big.Int).Add(balance, &firstBlocksInfo[0].Cost).Cmp(big.NewInt(50000000000000000)) != 0 { t.Fatalf("unexpected pending state balance %v", balance) } } func TestNumChainsChange(t *testing.T) { key, err := crypto.GenerateKey() if err != nil { t.Fatalf("hex to ecdsa error: %v", err) } params.TestnetChainConfig.Dexcon.Owner = crypto.PubkeyToAddress(key.PublicKey) dex, err := newTestDexonWithGenesis(key) if err != nil { t.Fatalf("new test dexon error: %v", err) } chainID := new(big.Int).Mod(crypto.PubkeyToAddress(key.PublicKey).Big(), big.NewInt(int64(dex.chainConfig.Dexcon.NumChains))) root := dex.blockchain.CurrentBlock().Root() dex.app.chainRoot.Store(uint32(chainID.Uint64()), &root) abiObject, err := abi.JSON(strings.NewReader(vm.GovernanceABIJSON)) if err != nil { t.Fatalf("get abi object fail: %v", err) } // Update config in round 1 and height 1. // Config will affect in round 3. input, err := abiObject.Pack("updateConfiguration", new(big.Int).Mul(big.NewInt(1e18), big.NewInt(1e4)), big.NewInt(2000), big.NewInt(0.1875*1e8), big.NewInt(1e18), big.NewInt(1e18), big.NewInt(9000000), big.NewInt(3), big.NewInt(500), big.NewInt(5000), big.NewInt(1), big.NewInt(700000), big.NewInt(5), big.NewInt(5), big.NewInt(700000), big.NewInt(1000), []*big.Int{big.NewInt(1), big.NewInt(1), big.NewInt(1)}) if err != nil { t.Fatalf("updateConfiguration abiObject pack error: %v", err) } block, err := prepareConfirmedBlockWithTxAndData(dex, key, [][]byte{input}, 1) if err != nil { t.Fatalf("prepare block error: %v", err) } dex.app.BlockDelivered(block.Hash, block.Position, coreTypes.FinalizationResult{ Timestamp: time.Now(), Height: 1, }) // Snapshot round on round 1 and height 2. input, err = abiObject.Pack("snapshotRound", big.NewInt(1), big.NewInt(1)) if err != nil { t.Fatalf("abiObject pack error: %v", err) } block, err = prepareConfirmedBlockWithTxAndData(dex, key, [][]byte{input}, 1) if err != nil { t.Fatalf("prepare block error: %v", err) } dex.app.BlockDelivered(block.Hash, block.Position, coreTypes.FinalizationResult{ Timestamp: time.Now(), Height: 2, }) // Make round 1 height 2 block write into chain. block, err = prepareConfirmedBlockWithTxAndData(dex, key, nil, 1) if err != nil { t.Fatalf("prepare block error: %v", err) } dex.app.BlockDelivered(block.Hash, block.Position, coreTypes.FinalizationResult{ Timestamp: time.Now(), Height: 3, }) // Round 2 will keep prepare tx as usual. block, err = prepareConfirmedBlockWithTxAndData(dex, key, [][]byte{{1}}, 2) if err != nil { t.Fatalf("prepare block error: %v", err) } if block.Payload == nil { t.Fatalf("payload should not be nil") } dex.app.BlockDelivered(block.Hash, block.Position, coreTypes.FinalizationResult{ Timestamp: time.Now(), Height: 4, }) // It will prepare empty payload until witness any block in round 3. block, err = prepareConfirmedBlockWithTxAndData(dex, key, [][]byte{{1}}, 3) if err != nil { t.Fatalf("prepare block error: %v", err) } if block.Payload != nil { t.Fatalf("payload should be nil but %v", block.Payload) } // Test non-empty payload. block.Payload = []byte{1} if status := dex.app.VerifyBlock(block); status != coreTypes.VerifyInvalidBlock { t.Fatalf("unexpected verify status %v", status) } block.Payload = nil dex.app.BlockDelivered(block.Hash, block.Position, coreTypes.FinalizationResult{ Timestamp: time.Now(), Height: 5, }) // Empty block in round 3 has been delivered. // Now can prepare payload as usual. block, err = prepareConfirmedBlockWithTxAndData(dex, key, [][]byte{{1}}, 3) if err != nil { t.Fatalf("prepare block error: %v", err) } if block.Payload == nil { t.Fatalf("payload should not be nil") } dex.app.BlockDelivered(block.Hash, block.Position, coreTypes.FinalizationResult{ Timestamp: time.Now(), Height: 6, }) } func BenchmarkBlockDeliveredFlow(b *testing.B) { key, err := crypto.GenerateKey() if err != nil { b.Fatalf("hex to ecdsa error: %v", err) return } dex, err := newTestDexonWithGenesis(key) if err != nil { b.Fatalf("new test dexon error: %v", err) } b.ResetTimer() for i := 1; i <= b.N; i++ { blocksInfo, err := prepareConfirmedBlocks(dex, []*ecdsa.PrivateKey{key}, 100) if err != nil { b.Fatalf("preapare confirmed block error: %v", err) return } dex.app.BlockDelivered(blocksInfo[0].Block.Hash, blocksInfo[0].Block.Position, coreTypes.FinalizationResult{ Timestamp: time.Now(), Height: uint64(i), }) } } func newTestDexonWithGenesis(allocKey *ecdsa.PrivateKey) (*Dexon, error) { db := ethdb.NewMemDatabase() key, err := crypto.GenerateKey() if err != nil { panic(err) } testBankAddress := crypto.PubkeyToAddress(allocKey.PublicKey) genesis := core.DefaultTestnetGenesisBlock() genesis.Alloc = core.GenesisAlloc{ testBankAddress: { Balance: big.NewInt(100000000000000000), Staked: big.NewInt(50000000000000000), PublicKey: crypto.FromECDSAPub(&key.PublicKey), }, } chainConfig, _, err := core.SetupGenesisBlock(db, genesis) if err != nil { return nil, err } config := Config{PrivateKey: key} vmConfig := vm.Config{IsBlockProposer: true} engine := dexcon.New() dex := &Dexon{ chainDb: db, chainConfig: chainConfig, networkID: config.NetworkId, engine: engine, } dex.blockchain, err = core.NewBlockChain(db, nil, chainConfig, engine, vmConfig, nil) if err != nil { return nil, err } txPoolConfig := core.DefaultTxPoolConfig dex.txPool = core.NewTxPool(txPoolConfig, chainConfig, dex.blockchain, true) dex.APIBackend = &DexAPIBackend{dex, nil} dex.governance = NewDexconGovernance(dex.APIBackend, dex.chainConfig, config.PrivateKey) engine.SetGovStateFetcher(dex.governance) dex.app = NewDexconApp(dex.txPool, dex.blockchain, dex.governance, db, &config) return dex, nil } // Add tx into tx pool. func addTx(dex *Dexon, nonce int, signer types.Signer, key *ecdsa.PrivateKey) ( *types.Transaction, error) { tx := types.NewTransaction( uint64(nonce), common.BytesToAddress([]byte{9}), big.NewInt(int64(nonce*1)), params.TxGas, big.NewInt(1), nil) tx, err := types.SignTx(tx, signer, key) if err != nil { return nil, err } if err := dex.txPool.AddRemote(tx); err != nil { return nil, err } return tx, nil } // Prepare data with given transaction number and start nonce. func prepareData(dex *Dexon, key *ecdsa.PrivateKey, startNonce, txNum int) ( payload []byte, witness coreTypes.Witness, cost big.Int, nonce uint64, err error) { signer := types.NewEIP155Signer(dex.chainConfig.ChainID) chainID := new(big.Int).Mod(crypto.PubkeyToAddress(key.PublicKey).Big(), big.NewInt(int64(dex.chainConfig.Dexcon.NumChains))) for n := startNonce; n < startNonce+txNum; n++ { var tx *types.Transaction tx, err = addTx(dex, n, signer, key) if err != nil { return } cost.Add(&cost, tx.Cost()) nonce = uint64(n) } payload, err = dex.app.PreparePayload(coreTypes.Position{ChainID: uint32(chainID.Uint64())}) if err != nil { return } witness, err = dex.app.PrepareWitness(0) if err != nil { return } return } func prepareConfirmedBlockWithTxAndData(dex *Dexon, key *ecdsa.PrivateKey, data [][]byte, round uint64) ( Block *coreTypes.Block, err error) { address := crypto.PubkeyToAddress(key.PublicKey) numChains := dex.governance.GetGovStateHelperAtRound(round).Configuration().NumChains chainID := new(big.Int).Mod(address.Big(), big.NewInt(int64(numChains))) for _, d := range data { // Prepare one block for pending. nonce := dex.txPool.State().GetNonce(address) signer := types.NewEIP155Signer(dex.chainConfig.ChainID) tx := types.NewTransaction(uint64(nonce), vm.GovernanceContractAddress, big.NewInt(0), params.TxGas*2, big.NewInt(1), d) tx, err = types.SignTx(tx, signer, key) if err != nil { return nil, err } dex.txPool.AddRemote(tx) if err != nil { return nil, err } } var ( payload []byte witness coreTypes.Witness ) payload, err = dex.app.PreparePayload(coreTypes.Position{Round: round, ChainID: uint32(chainID.Uint64())}) if err != nil { return } witness, err = dex.app.PrepareWitness(0) if err != nil { return nil, err } block := &coreTypes.Block{} block.Hash = coreCommon.NewRandomHash() block.Witness = witness block.Payload = payload block.Position.ChainID = uint32(chainID.Uint64()) block.Position.Round = round block.ProposerID = coreTypes.NodeID{coreCommon.Hash{1, 2, 3}} status := dex.app.VerifyBlock(block) if status != coreTypes.VerifyOK { err = fmt.Errorf("verify fail: %v", status) return nil, err } dex.app.BlockConfirmed(*block) return block, nil } func prepareDataWithoutTxPool(dex *Dexon, key *ecdsa.PrivateKey, startNonce, txNum int) ( payload []byte, witness coreTypes.Witness, err error) { signer := types.NewEIP155Signer(dex.chainConfig.ChainID) var transactions types.Transactions for n := startNonce; n < startNonce+txNum; n++ { tx := types.NewTransaction( uint64(n), common.BytesToAddress([]byte{9}), big.NewInt(int64(n*1)), params.TxGas, big.NewInt(1), nil) tx, err = types.SignTx(tx, signer, key) if err != nil { return } transactions = append(transactions, tx) } payload, err = rlp.EncodeToBytes(&transactions) if err != nil { return } witness, err = dex.app.PrepareWitness(0) if err != nil { return } return } func prepareConfirmedBlocks(dex *Dexon, keys []*ecdsa.PrivateKey, txNum int) (blocksInfo []struct { Block *coreTypes.Block Cost big.Int Nonce uint64 }, err error) { for _, key := range keys { address := crypto.PubkeyToAddress(key.PublicKey) chainID := new(big.Int).Mod(address.Big(), big.NewInt(int64(dex.chainConfig.Dexcon.NumChains))) // Prepare one block for pending. var ( payload []byte witness coreTypes.Witness cost big.Int nonce uint64 ) startNonce := dex.txPool.State().GetNonce(address) payload, witness, cost, nonce, err = prepareData(dex, key, int(startNonce), txNum) if err != nil { err = fmt.Errorf("prepare data error: %v", err) return } block := &coreTypes.Block{} block.Hash = coreCommon.NewRandomHash() block.Witness = witness block.Payload = payload block.Position.ChainID = uint32(chainID.Uint64()) block.ProposerID = coreTypes.NodeID{coreCommon.Hash{1, 2, 3}} status := dex.app.VerifyBlock(block) if status != coreTypes.VerifyOK { err = fmt.Errorf("verify fail: %v", status) return } dex.app.BlockConfirmed(*block) blocksInfo = append(blocksInfo, struct { Block *coreTypes.Block Cost big.Int Nonce uint64 }{Block: block, Cost: cost, Nonce: nonce}) } return }