"github.com/vapor/blockchain/pseudohsm"
"github.com/vapor/blockchain/signers"
"github.com/vapor/blockchain/txbuilder"
+ "github.com/vapor/config"
"github.com/vapor/consensus"
- "github.com/vapor/consensus/difficulty"
"github.com/vapor/crypto/ed25519/chainkd"
"github.com/vapor/database"
dbm "github.com/vapor/database/leveldb"
"github.com/vapor/database/storage"
"github.com/vapor/event"
- "github.com/vapor/mining"
+ "github.com/vapor/proposal"
"github.com/vapor/protocol"
"github.com/vapor/protocol/bc"
"github.com/vapor/protocol/bc/types"
// init UtxoViewpoint
utxoView := state.NewUtxoViewpoint()
- utxoEntry := storage.NewUtxoEntry(false, 1, false)
+ utxoEntry := storage.NewUtxoEntry(storage.NormalUTXOType, 1, false)
for _, tx := range txs {
for _, id := range tx.SpentOutputIDs {
utxoView.Entries[id] = utxoEntry
return nil, nil, nil, err
}
+ config.CommonConfig = config.DefaultConfig()
store := database.NewStore(testDB)
dispatcher := event.NewDispatcher()
txPool := protocol.NewTxPool(store, dispatcher)
- chain, err := protocol.NewChain(store, txPool)
+ chain, err := protocol.NewChain(store, txPool, dispatcher)
if err != nil {
return nil, nil, nil, err
}
}
}
- block, err := mining.NewBlockTemplate(chain, txPool, nil)
+ block, err := proposal.NewBlockTemplate(chain, txPool, nil, uint64(time.Now().UnixNano()/1e6))
if err != nil {
return err
}
fmt.Println("txsize:", uint64(block.Transactions[1].SerializedSize))
}
- seed, err := chain.CalcNextSeed(&block.PreviousBlockHash)
- if err != nil {
- return err
- }
-
- if err := SolveBlock(seed, block); err != nil {
- return err
- }
-
if _, err := chain.ProcessBlock(block); err != nil {
return err
}
func processNewTxch(txPool *protocol.TxPool) {
}
-func SolveBlock(seed *bc.Hash, block *types.Block) error {
- maxNonce := ^uint64(0) // 2^64 - 1
- header := &block.BlockHeader
- for i := uint64(0); i < maxNonce; i++ {
- header.Nonce = i
- headerHash := header.Hash()
- if difficulty.CheckProofOfWork(&headerHash, seed, header.Bits) {
- return nil
- }
- }
- return nil
-}
-
func MockSimpleUtxo(index uint64, assetID *bc.AssetID, amount uint64, ctrlProg *account.CtrlProgram) *account.UTXO {
if ctrlProg == nil {
ctrlProg = &account.CtrlProgram{
}
func AddTxOutput(assetID bc.AssetID, amount uint64, controlProgram []byte) *types.TxOutput {
- out := types.NewTxOutput(assetID, amount, controlProgram)
+ out := types.NewIntraChainOutput(assetID, amount, controlProgram)
return out
}
//-------------------------Mock actual transaction----------------------------------
func MockTxsP2PKH(keyDirPath string, testDB dbm.DB, txNumber, otherAssetNum int) ([]*types.Tx, error) {
- accountManager := account.NewManager(testDB, nil)
+ accountStore := database.NewAccountStore(testDB)
+ accountManager := account.NewManager(accountStore, nil)
hsm, err := pseudohsm.New(keyDirPath)
if err != nil {
return nil, err
}
func MockTxsP2SH(keyDirPath string, testDB dbm.DB, txNumber, otherAssetNum int) ([]*types.Tx, error) {
- accountManager := account.NewManager(testDB, nil)
+ accountStore := database.NewAccountStore(testDB)
+ accountManager := account.NewManager(accountStore, nil)
hsm, err := pseudohsm.New(keyDirPath)
if err != nil {
return nil, err
}
func MockTxsMultiSign(keyDirPath string, testDB dbm.DB, txNumber, otherAssetNum int) ([]*types.Tx, error) {
- accountManager := account.NewManager(testDB, nil)
+ accountStore := database.NewAccountStore(testDB)
+ accountManager := account.NewManager(accountStore, nil)
hsm, err := pseudohsm.New(keyDirPath)
if err != nil {
return nil, err