// NewBlockDeepCopy deep copies an entire block down to the wire components and
// returns the new block based off of this copy.
func NewBlockDeepCopy(msgBlock *wire.MsgBlock) *Block {
// Deep copy the header and all the transactions.
msgBlockCopy := new(wire.MsgBlock)
lenTxs := len(msgBlock.Transactions)
mtxsCopy := make([]*wire.MsgTx, lenTxs)
for i, mtx := range msgBlock.Transactions {
txd := NewTxDeep(mtx)
mtxsCopy[i] = txd.MsgTx()
}
msgBlockCopy.Transactions = mtxsCopy
lenStxs := len(msgBlock.STransactions)
smtxsCopy := make([]*wire.MsgTx, lenStxs)
for i, smtx := range msgBlock.STransactions {
stxd := NewTxDeep(smtx)
smtxsCopy[i] = stxd.MsgTx()
}
msgBlockCopy.STransactions = smtxsCopy
msgBlockCopy.Header = msgBlock.Header
bl := &Block{
blockHeight: int64(msgBlockCopy.Header.Height),
msgBlock: msgBlockCopy,
}
bl.hash = msgBlock.BlockSha()
return bl
}
// NewBlockDeepCopyCoinbase returns a new instance of a block given an underlying
// wire.MsgBlock, but makes a deep copy of the coinbase transaction since it's
// sometimes mutable.
func NewBlockDeepCopyCoinbase(msgBlock *wire.MsgBlock) *Block {
// Copy the msgBlock and the pointers to all the transactions.
msgBlockCopy := new(wire.MsgBlock)
lenTxs := len(msgBlock.Transactions)
mtxsCopy := make([]*wire.MsgTx, lenTxs)
for i, mtx := range msgBlock.Transactions {
mtxsCopy[i] = mtx
}
msgBlockCopy.Transactions = mtxsCopy
lenStxs := len(msgBlock.STransactions)
smtxsCopy := make([]*wire.MsgTx, lenStxs)
for i, smtx := range msgBlock.STransactions {
smtxsCopy[i] = smtx
}
msgBlockCopy.STransactions = smtxsCopy
msgBlockCopy.Header = msgBlock.Header
// Deep copy the first transaction. Also change the coinbase pointer.
msgBlockCopy.Transactions[0] =
NewTxDeep(msgBlockCopy.Transactions[0]).MsgTx()
bl := &Block{
blockHeight: int64(msgBlockCopy.Header.Height),
msgBlock: msgBlockCopy,
}
bl.hash = msgBlock.BlockSha()
return bl
}
// NewBlock returns a new instance of a block given an underlying
// wire.MsgBlock. See Block.
func NewBlock(msgBlock *wire.MsgBlock) *Block {
return &Block{
hash: msgBlock.BlockSha(),
msgBlock: msgBlock,
blockHeight: BlockHeightUnknown,
}
}
// NewBlockFromBlockAndBytes returns a new instance of a block given
// an underlying wire.MsgBlock and the serialized bytes for it. See Block.
func NewBlockFromBlockAndBytes(msgBlock *wire.MsgBlock, serializedBlock []byte) *Block {
return &Block{
hash: msgBlock.BlockSha(),
msgBlock: msgBlock,
serializedBlock: serializedBlock,
blockHeight: BlockHeightUnknown,
}
}
// NewBlockFromReader returns a new instance of a block given a
// Reader to deserialize the block. See Block.
func NewBlockFromReader(r io.Reader) (*Block, error) {
// Deserialize the bytes into a MsgBlock.
var msgBlock wire.MsgBlock
err := msgBlock.Deserialize(r)
if err != nil {
return nil, err
}
b := Block{
hash: msgBlock.BlockSha(),
msgBlock: &msgBlock,
blockHeight: BlockHeightUnknown,
}
return &b, nil
}
Header: wire.BlockHeader{
Version: 1,
PrevBlock: chainhash.Hash{},
MerkleRoot: genesisMerkleRoot,
StakeRoot: chainhash.Hash{},
Timestamp: time.Unix(1454954400, 0), // Mon, 08 Feb 2016 18:00:00 GMT
Bits: 0x1b01ffff, // Difficulty 32767
SBits: 2 * 1e8, // 2 Coin
Nonce: 0x00000000,
},
Transactions: []*wire.MsgTx{&genesisCoinbaseTx},
}
// genesisHash is the hash of the first block in the block chain for the main
// network (genesis block).
var genesisHash = genesisBlock.BlockSha()
// TestNet ------------------------------------------------------------------------
// genesisCoinbaseTxLegacy is the coinbase transaction for the genesis block for
// the test network.
var genesisCoinbaseTxLegacy = wire.MsgTx{
Version: 1,
TxIn: []*wire.TxIn{
{
PreviousOutPoint: wire.OutPoint{
Hash: chainhash.Hash{},
Index: 0xffffffff,
},
SignatureScript: []byte{
0x04, 0xff, 0xff, 0x00, 0x1d, 0x01, 0x04, 0x45, /* |.......E| */
