PKU Blockchain Course: Bitcoin

SubsidyReductionInterval: 210000,
TargetTimespan:           time.Hour * 24 * 14, // 14 days
TargetTimePerBlock:       time.Minute * 10,    // 10 minutes
RetargetAdjustmentFactor: 4,                   // 25% less, 400% more
// TargetTimespan / TargetTimePerBlock == 2016

const CheckpointConfirmations = 2016

// https://github.com/btcsuite/btcwallet/blob/v0.16.5/internal/legacy/keystore/keystore.go#L2148

func newBtcAddress(wallet *Store, privkey, iv []byte, bs *BlockStamp, compressed bool) (addr *btcAddress, err error) {

addr, err = newBtcAddressWithoutPrivkey(wallet,
	pubkeyFromPrivkey(privkey, compressed), iv, bs)

address, err := btcutil.NewAddressPubKeyHash(btcutil.Hash160(pubkey), s.netParams())

// Hash160 calculates the hash ripemd160(sha256(b)).
func Hash160(buf []byte) []byte {
	return calcHash(calcHash(buf, sha256.New()), ripemd160.New())
}

// https://developer.bitcoin.org/reference/block_chain.html#block-headers

// https://github.com/btcsuite/btcd/blob/v0.23.3/wire/blockheader.go#L20

type BlockHeader struct {
	// Version of the block.  This is not the same as the protocol version.
    // This indicates which set of block validation rules to follow.
	Version int32
	// Hash of the previous block header in the block chain.
	PrevBlock chainhash.Hash
	// Merkle tree reference to hash of all transactions for the block.
	MerkleRoot chainhash.Hash
	// Time the block was created.  This is, unfortunately, encoded as a
	// uint32 on the wire and therefore is limited to 2106.
	Timestamp time.Time
	// Difficulty target for the block.
	Bits uint32
	// Nonce used to generate the block.
	Nonce uint32
}

// https://github.com/btcsuite/btcd/blob/v0.23.3/blockchain/validate.go#L81

// A coinbase is a special transaction created by miners that has no inputs.  This is
// represented in the block chain by a transaction with a single input that has
// a previous output transaction index set to the maximum value along with a
// zero hash.
//
// This function only differs from IsCoinBase in that it works with a raw wire
// transaction as opposed to a higher level util transaction.
func IsCoinBaseTx(msgTx *wire.MsgTx) bool {
	// A coin base must only have one transaction input.
	if len(msgTx.TxIn) != 1 {
		return false
	}
	// The previous output of a coin base must have a max value index and
	// a zero hash.
	prevOut := &msgTx.TxIn[0].PreviousOutPoint
	if prevOut.Index != math.MaxUint32 || prevOut.Hash != zeroHash {
		return false
	}
	return true
}

// https://github.com/btcsuite/btcd/blob/v0.23.3/btcjson/chainsvrresults.go#L710

// TxRawResult models the data from the getrawtransaction command.
type TxRawResult struct {
	Hex           string `json:"hex"`
	Txid          string `json:"txid"`
	Hash          string `json:"hash,omitempty"`
	Size          int32  `json:"size,omitempty"`
	Vsize         int32  `json:"vsize,omitempty"`
	Weight        int32  `json:"weight,omitempty"`
	Version       uint32 `json:"version"`	// 比特币协议版本号
	LockTime      uint32 `json:"locktime"`
	Vin           []Vin  `json:"vin"`
	Vout          []Vout `json:"vout"`
	BlockHash     string `json:"blockhash,omitempty"`
	Confirmations uint64 `json:"confirmations,omitempty"`
	Time          int64  `json:"time,omitempty"`
	Blocktime     int64  `json:"blocktime,omitempty"`
}

// https://github.com/btcsuite/btcd/blob/v0.23.3/wire/msgtx.go#L236

// TxIn defines a bitcoin transaction input.
type TxIn struct {
	PreviousOutPoint OutPoint
	SignatureScript  []byte
	Witness          TxWitness
	Sequence         uint32
}
    // OutPoint defines a bitcoin data type that is used to track previous
    // transaction outputs.
    type OutPoint struct {
        Hash  chainhash.Hash	// tx id
        Index uint32
    }
    // TxWitness defines the witness for a TxIn. A witness is to be interpreted as
    // a slice of byte slices, or a stack with one or many elements.
    type TxWitness [][]byte

// TxOut defines a bitcoin transaction output.
type TxOut struct {
	Value    int64
	PkScript []byte
}

// https://github.com/btcsuite/btcd/blob/v0.23.3/mining/cpuminer/cpuminer.go#L198

func (m *CPUMiner) solveBlock(msgBlock *wire.MsgBlock, blockHeight int32,
        ticker *time.Ticker, quit chan struct{}) bool {
    // Choose a random extra nonce offset for this block template and
	// worker.
	enOffset, err := wire.RandomUint64()

    header := &msgBlock.Header
	targetDifficulty := blockchain.CompactToBig(header.Bits)

    // Note that the entire extra nonce range is iterated and the offset is
	// added relying on the fact that overflow will wrap around 0 as
	// provided by the Go spec.
	for extraNonce := uint64(0); extraNonce < maxExtraNonce; extraNonce++ {
		// Update the extra nonce in the block template with the
		// new value by regenerating the coinbase script and
		// setting the merkle root to the new value.
		m.g.UpdateExtraNonce(msgBlock, blockHeight, extraNonce+enOffset)

		// Search through the entire nonce range for a solution while
		// periodically checking for early quit and stale block
		// conditions along with updates to the speed monitor.
		for i := uint32(0); i <= maxNonce; i++ {
        }
}

const (
	// maxNonce is the maximum value a nonce can be in a block header.
	maxNonce = ^uint32(0) // 2^32 - 1
	// maxExtraNonce is the maximum value an extra nonce used in a coinbase
	// transaction can be.
	maxExtraNonce = ^uint64(0) // 2^64 - 1
)

// https://github.com/btcsuite/btcd/blob/v0.23.3/mining/mining.go#L381

func (g *BlkTmplGenerator) NewBlockTemplate(payToAddress btcutil.Address) (*BlockTemplate, error) {}

func (b *BlockChain) calcNextRequiredDifficulty(lastNode *blockNode, newBlockTime time.Time) (uint32, error) {
	// newTarget = currentDifficulty * (actualTimespan / targetTimespan)
}