Merge pull request #1137 from Bytom/v1.0.3_fix

[bytom/bytom.git] / config / genesis.go

diff --git a/config/genesis.go b/config/genesis.go
index 0a62ec9..38ee157 100644 (file)
--- a/config/genesis.go
+++ b/config/genesis.go
@@ -1,73 +1,131 @@
 package config
 
 import (
+       "encoding/hex"
+
        log "github.com/sirupsen/logrus"
 
        "github.com/bytom/consensus"
-       "github.com/bytom/consensus/difficulty"
-       "github.com/bytom/crypto/sha3pool"
        "github.com/bytom/protocol/bc"
-       "github.com/bytom/protocol/bc/legacy"
+       "github.com/bytom/protocol/bc/types"
 )
 
-// GenerateGenesisTx will return genesis transaction
-func GenerateGenesisTx() *legacy.Tx {
-       txData := legacy.TxData{
-               Version:        1,
-               SerializedSize: 63,
-               Inputs:         []*legacy.TxInput{},
-               Outputs: []*legacy.TxOutput{
-                       &legacy.TxOutput{
-                               AssetVersion: 1,
-                               OutputCommitment: legacy.OutputCommitment{
-                                       AssetAmount: bc.AssetAmount{
-                                               AssetId: consensus.BTMAssetID,
-                                               Amount:  1470000000000000000,
-                                       },
-                                       VMVersion:      1,
-                                       ControlProgram: []byte{81},
-                               },
-                       },
+func genesisTx() *types.Tx {
+       contract, err := hex.DecodeString("00148c9d063ff74ee6d9ffa88d83aeb038068366c4c4")
+       if err != nil {
+               log.Panicf("fail on decode genesis tx output control program")
+       }
+
+       txData := types.TxData{
+               Version: 1,
+               Inputs: []*types.TxInput{
+                       types.NewCoinbaseInput([]byte("Information is power. -- Jan/11/2013. Computing is power. -- Apr/24/2018.")),
+               },
+               Outputs: []*types.TxOutput{
+                       types.NewTxOutput(*consensus.BTMAssetID, consensus.InitialBlockSubsidy, contract),
                },
        }
+       return types.NewTx(txData)
+}
 
-       return legacy.NewTx(txData)
+func mainNetGenesisBlock() *types.Block {
+       tx := genesisTx()
+       txStatus := bc.NewTransactionStatus()
+       txStatus.SetStatus(0, false)
+       txStatusHash, err := bc.TxStatusMerkleRoot(txStatus.VerifyStatus)
+       if err != nil {
+               log.Panicf("fail on calc genesis tx status merkle root")
+       }
+
+       merkleRoot, err := bc.TxMerkleRoot([]*bc.Tx{tx.Tx})
+       if err != nil {
+               log.Panicf("fail on calc genesis tx merkel root")
+       }
+
+       block := &types.Block{
+               BlockHeader: types.BlockHeader{
+                       Version:   1,
+                       Height:    0,
+                       Nonce:     9253507043297,
+                       Timestamp: 1524549600,
+                       Bits:      2161727821137910632,
+                       BlockCommitment: types.BlockCommitment{
+                               TransactionsMerkleRoot: merkleRoot,
+                               TransactionStatusHash:  txStatusHash,
+                       },
+               },
+               Transactions: []*types.Tx{tx},
+       }
+       return block
 }
 
-// GenerateGenesisBlock will return genesis block
-func GenerateGenesisBlock() *legacy.Block {
-       genesisCoinbaseTx := GenerateGenesisTx()
-       merkleRoot, err := bc.MerkleRoot([]*bc.Tx{genesisCoinbaseTx.Tx})
+func testNetGenesisBlock() *types.Block {
+       tx := genesisTx()
+       txStatus := bc.NewTransactionStatus()
+       txStatus.SetStatus(0, false)
+       txStatusHash, err := bc.TxStatusMerkleRoot(txStatus.VerifyStatus)
        if err != nil {
-               log.Panicf("Fatal create merkelRoot")
+               log.Panicf("fail on calc genesis tx status merkle root")
        }
 
-       var seed [32]byte
-       sha3pool.Sum256(seed[:], make([]byte, 32))
+       merkleRoot, err := bc.TxMerkleRoot([]*bc.Tx{tx.Tx})
+       if err != nil {
+               log.Panicf("fail on calc genesis tx merkel root")
+       }
 
-       genesisBlock := &legacy.Block{
-               BlockHeader: legacy.BlockHeader{
-                       Version:     1,
-                       Height:      1,
-                       Seed:        bc.NewHash(seed),
-                       TimestampMS: 1511318565142,
-                       BlockCommitment: legacy.BlockCommitment{
+       block := &types.Block{
+               BlockHeader: types.BlockHeader{
+                       Version:   1,
+                       Height:    0,
+                       Nonce:     9253507043297,
+                       Timestamp: 1528945000,
+                       Bits:      2305843009214532812,
+                       BlockCommitment: types.BlockCommitment{
                                TransactionsMerkleRoot: merkleRoot,
+                               TransactionStatusHash:  txStatusHash,
                        },
-                       Bits: 2161727821138738707,
                },
-               Transactions: []*legacy.Tx{genesisCoinbaseTx},
+               Transactions: []*types.Tx{tx},
+       }
+       return block
+}
+
+func soloNetGenesisBlock() *types.Block {
+       tx := genesisTx()
+       txStatus := bc.NewTransactionStatus()
+       txStatus.SetStatus(0, false)
+       txStatusHash, err := bc.TxStatusMerkleRoot(txStatus.VerifyStatus)
+       if err != nil {
+               log.Panicf("fail on calc genesis tx status merkle root")
        }
 
-       for i := uint64(0); i <= 10000000000000; i++ {
-               genesisBlock.Nonce = i
-               hash := genesisBlock.Hash()
+       merkleRoot, err := bc.TxMerkleRoot([]*bc.Tx{tx.Tx})
+       if err != nil {
+               log.Panicf("fail on calc genesis tx merkel root")
+       }
 
-               if difficulty.CheckProofOfWork(&hash, genesisBlock.Bits) {
-                       break
-               }
+       block := &types.Block{
+               BlockHeader: types.BlockHeader{
+                       Version:   1,
+                       Height:    0,
+                       Nonce:     9253507043297,
+                       Timestamp: 1528945000,
+                       Bits:      2305843009214532812,
+                       BlockCommitment: types.BlockCommitment{
+                               TransactionsMerkleRoot: merkleRoot,
+                               TransactionStatusHash:  txStatusHash,
+                       },
+               },
+               Transactions: []*types.Tx{tx},
        }
+       return block
+}
 
-       log.Infof("genesisBlock:%v", genesisBlock)
-       return genesisBlock
+// GenesisBlock will return genesis block
+func GenesisBlock() *types.Block {
+       return map[string]func() *types.Block{
+               "main": mainNetGenesisBlock,
+               "test": testNetGenesisBlock,
+               "solo": soloNetGenesisBlock,
+       }[consensus.ActiveNetParams.Name]()
 }