blockchain

package module
Version: v1.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Aug 8, 2019 License: ISC Imports: 22 Imported by: 269

README

blockchain

Build Status ISC License GoDoc

Package blockchain implements Decred block handling and chain selection rules. The test coverage is currently only around 60%, but will be increasing over time. See test_coverage.txt for the gocov coverage report. Alternatively, if you are running a POSIX OS, you can run the cov_report.sh script for a real-time report. Package blockchain is licensed under the liberal ISC license.

There is an associated blog post about the release of this package here.

This package has intentionally been designed so it can be used as a standalone package for any projects needing to handle processing of blocks into the decred block chain.

Installation and Updating

$ go get -u github.com/decred/dcrd/blockchain

Decred Chain Processing Overview

Before a block is allowed into the block chain, it must go through an intensive series of validation rules. The following list serves as a general outline of those rules to provide some intuition into what is going on under the hood, but is by no means exhaustive:

  • Reject duplicate blocks
  • Perform a series of sanity checks on the block and its transactions such as verifying proof of work, timestamps, number and character of transactions, transaction amounts, script complexity, and merkle root calculations
  • Compare the block against predetermined checkpoints for expected timestamps and difficulty based on elapsed time since the checkpoint
  • Save the most recent orphan blocks for a limited time in case their parent blocks become available
  • Stop processing if the block is an orphan as the rest of the processing depends on the block's position within the block chain
  • Perform a series of more thorough checks that depend on the block's position within the block chain such as verifying block difficulties adhere to difficulty retarget rules, timestamps are after the median of the last several blocks, all transactions are finalized, checkpoint blocks match, and block versions are in line with the previous blocks
  • Determine how the block fits into the chain and perform different actions accordingly in order to ensure any side chains which have higher difficulty than the main chain become the new main chain
  • When a block is being connected to the main chain (either through reorganization of a side chain to the main chain or just extending the main chain), perform further checks on the block's transactions such as verifying transaction duplicates, script complexity for the combination of connected scripts, coinbase maturity, double spends, and connected transaction values
  • Run the transaction scripts to verify the spender is allowed to spend the coins
  • Insert the block into the block database

Examples

  • ProcessBlock Example Demonstrates how to create a new chain instance and use ProcessBlock to attempt to add a block to the chain. This example intentionally attempts to insert a duplicate genesis block to illustrate how an invalid block is handled.

  • CompactToBig Example Demonstrates how to convert the compact "bits" in a block header which represent the target difficulty to a big integer and display it using the typical hex notation.

  • BigToCompact Example Demonstrates how to convert how to convert a target difficulty into the compact "bits" in a block header which represent that target difficulty.

License

Package blockchain is licensed under the copyfree ISC License.

Documentation

Overview

Package blockchain implements Decred block handling and chain selection rules.

The Decred block handling and chain selection rules are an integral, and quite likely the most important, part of decred. Unfortunately, at the time of this writing, these rules are also largely undocumented and had to be ascertained from the bitcoind source code. At its core, Decred is a distributed consensus of which blocks are valid and which ones will comprise the main block chain (public ledger) that ultimately determines accepted transactions, so it is extremely important that fully validating nodes agree on all rules.

At a high level, this package provides support for inserting new blocks into the block chain according to the aforementioned rules. It includes functionality such as rejecting duplicate blocks, ensuring blocks and transactions follow all rules, orphan handling, and best chain selection along with reorganization.

Since this package does not deal with other Decred specifics such as network communication or wallets, it provides a notification system which gives the caller a high level of flexibility in how they want to react to certain events such as orphan blocks which need their parents requested and newly connected main chain blocks which might result in wallet updates.

Decred Chain Processing Overview

Before a block is allowed into the block chain, it must go through an intensive series of validation rules. The following list serves as a general outline of those rules to provide some intuition into what is going on under the hood, but is by no means exhaustive:

- Reject duplicate blocks
- Perform a series of sanity checks on the block and its transactions such as
  verifying proof of work, timestamps, number and character of transactions,
  transaction amounts, script complexity, and merkle root calculations
- Compare the block against predetermined checkpoints for expected timestamps
  and difficulty based on elapsed time since the checkpoint
- Save the most recent orphan blocks for a limited time in case their parent
  blocks become available
- Stop processing if the block is an orphan as the rest of the processing
  depends on the block's position within the block chain
- Perform a series of more thorough checks that depend on the block's position
  within the block chain such as verifying block difficulties adhere to
  difficulty retarget rules, timestamps are after the median of the last
  several blocks, all transactions are finalized, checkpoint blocks match, and
  block versions are in line with the previous blocks
- Determine how the block fits into the chain and perform different actions
  accordingly in order to ensure any side chains which have higher difficulty
  than the main chain become the new main chain
- When a block is being connected to the main chain (either through
  reorganization of a side chain to the main chain or just extending the
  main chain), perform further checks on the block's transactions such as
  verifying transaction duplicates, script complexity for the combination of
  connected scripts, coinbase maturity, double spends, and connected
  transaction values
- Run the transaction scripts to verify the spender is allowed to spend the
  coins
- Insert the block into the block database

Errors

Errors returned by this package are either the raw errors provided by underlying calls or of type blockchain.RuleError. This allows the caller to differentiate between unexpected errors, such as database errors, versus errors due to rule violations through type assertions. In addition, callers can programmatically determine the specific rule violation by examining the ErrorCode field of the type asserted blockchain.RuleError.

Bitcoin Improvement Proposals

This package includes spec changes outlined by the following BIPs:

BIP0016 (https://en.bitcoin.it/wiki/BIP_0016)
BIP0030 (https://en.bitcoin.it/wiki/BIP_0030)
BIP0034 (https://en.bitcoin.it/wiki/BIP_0034)

Index

Examples

Constants

View Source
const (
	// MaxSigOpsPerBlock is the maximum number of signature operations
	// allowed for a block.  This really should be based upon the max
	// allowed block size for a network and any votes that might change it,
	// however, since it was not updated to be based upon it before
	// release, it will require a hard fork and associated vote agenda to
	// change it.  The original max block size for the protocol was 1MiB,
	// so that is what this is based on.
	MaxSigOpsPerBlock = 1000000 / 200

	// MaxTimeOffsetSeconds is the maximum number of seconds a block time
	// is allowed to be ahead of the current time.  This is currently 2
	// hours.
	MaxTimeOffsetSeconds = 2 * 60 * 60

	// MinCoinbaseScriptLen is the minimum length a coinbase script can be.
	MinCoinbaseScriptLen = 2

	// MaxCoinbaseScriptLen is the maximum length a coinbase script can be.
	MaxCoinbaseScriptLen = 100
)
View Source
const CheckpointConfirmations = 4096

CheckpointConfirmations is the number of blocks before the end of the current best block chain that a good checkpoint candidate must be.

Variables

This section is empty.

Functions

func BigToCompact deprecated

func BigToCompact(n *big.Int) uint32

BigToCompact converts a whole number N to a compact representation using an unsigned 32-bit number. The compact representation only provides 23 bits of precision, so values larger than (2^23 - 1) only encode the most significant digits of the number. See CompactToBig for details.

Deprecated: Use standalone.BigToCompact instead.

Example

This example demonstrates how to convert a target difficulty into the compact "bits" in a block header which represent that target difficulty .

package main

import (
	"fmt"
	"math/big"

	"github.com/decred/dcrd/blockchain"

	_ "github.com/decred/dcrd/database/ffldb"
)

func main() {
	// Convert the target difficulty from block 300000 in the main block
	// chain to compact form.
	t := "0000000000000000896c00000000000000000000000000000000000000000000"
	targetDifficulty, success := new(big.Int).SetString(t, 16)
	if !success {
		fmt.Println("invalid target difficulty")
		return
	}
	bits := blockchain.BigToCompact(targetDifficulty)

	fmt.Println(bits)

}
Output:

419465580

func BlockOneCoinbasePaysTokens deprecated

func BlockOneCoinbasePaysTokens(tx *dcrutil.Tx, params *chaincfg.Params) error

BlockOneCoinbasePaysTokens checks to see if the first block coinbase pays out to the network initial token ledger.

Deprecated: This will be removed in the next major version bump.

func BuildMerkleTreeStore deprecated

func BuildMerkleTreeStore(transactions []*dcrutil.Tx) []*chainhash.Hash

BuildMerkleTreeStore creates a merkle tree from a slice of transactions, stores it using a linear array, and returns a slice of the backing array. A linear array was chosen as opposed to an actual tree structure since it uses about half as much memory. The following describes a merkle tree and how it is stored in a linear array.

A merkle tree is a tree in which every non-leaf node is the hash of its children nodes. A diagram depicting how this works for Decred transactions where h(x) is a blake256 hash follows:

         root = h1234 = h(h12 + h34)
        /                           \
  h12 = h(h1 + h2)            h34 = h(h3 + h4)
   /            \              /            \
h1 = h(tx1)  h2 = h(tx2)    h3 = h(tx3)  h4 = h(tx4)

The above stored as a linear array is as follows:

[h1 h2 h3 h4 h12 h34 root]

As the above shows, the merkle root is always the last element in the array.

The number of inputs is not always a power of two which results in a balanced tree structure as above. In that case, parent nodes with no children are also zero and parent nodes with only a single left node are calculated by concatenating the left node with itself before hashing. Since this function uses nodes that are pointers to the hashes, empty nodes will be nil.

Deprecated: Use standalone.CalcTxTreeMerkleRoot instead.

func BuildMsgTxMerkleTreeStore deprecated

func BuildMsgTxMerkleTreeStore(transactions []*wire.MsgTx) []*chainhash.Hash

BuildMsgTxMerkleTreeStore is identical to BuildMerkleTreeStore but takes a slice of the wire.MsgTx transaction type instead of the dcrutil.Tx wrapper. See BuildMerkleTreeStore for more details.

Deprecated: Use standalone.CalcTxTreeMerkleRoot instead.

func CalcBlockTaxSubsidy deprecated

func CalcBlockTaxSubsidy(subsidyCache *SubsidyCache, height int64, voters uint16, params *chaincfg.Params) int64

CalcBlockTaxSubsidy calculates the subsidy for the organization address in the coinbase.

Safe for concurrent access.

Deprecated: Use standalone.SubsidyCache.CalcTreasurySubsidy instead.

func CalcBlockWorkSubsidy deprecated

func CalcBlockWorkSubsidy(subsidyCache *SubsidyCache, height int64, voters uint16, params *chaincfg.Params) int64

CalcBlockWorkSubsidy calculates the proof of work subsidy for a block as a proportion of the total subsidy.

Deprecated: Use standalone.SubsidyCache.CalcWorkSubsidy instead.

func CalcStakeVoteSubsidy deprecated

func CalcStakeVoteSubsidy(subsidyCache *SubsidyCache, height int64, params *chaincfg.Params) int64

CalcStakeVoteSubsidy calculates the subsidy for a stake vote based on the height of its input SStx.

Safe for concurrent access.

Deprecated: Use standalone.SubsidyCache.CalcStakeVoteSubsidy instead.

func CalcWork deprecated

func CalcWork(bits uint32) *big.Int

CalcWork calculates a work value from difficulty bits. Decred increases the difficulty for generating a block by decreasing the value which the generated hash must be less than. This difficulty target is stored in each block header using a compact representation as described in the documentation for CompactToBig. The main chain is selected by choosing the chain that has the most proof of work (highest difficulty). Since a lower target difficulty value equates to higher actual difficulty, the work value which will be accumulated must be the inverse of the difficulty. Also, in order to avoid potential division by zero and really small floating point numbers, the result adds 1 to the denominator and multiplies the numerator by 2^256.

Deprecated: Use standalone.CalcWork instead.

func CalculateAddedSubsidy deprecated

func CalculateAddedSubsidy(block, parent *dcrutil.Block) int64

CalculateAddedSubsidy calculates the amount of subsidy added by a block and its parent. The blocks passed to this function MUST be valid blocks that have already been confirmed to abide by the consensus rules of the network, or the function might panic.

Deprecated: This will no longer be exported in the next major version.

func CheckBlockSanity

func CheckBlockSanity(block *dcrutil.Block, timeSource MedianTimeSource, chainParams *chaincfg.Params) error

CheckBlockSanity performs some preliminary checks on a block to ensure it is sane before continuing with block processing. These checks are context free.

func CheckProofOfStake

func CheckProofOfStake(block *dcrutil.Block, posLimit int64) error

CheckProofOfStake ensures that all ticket purchases in the block pay at least the amount required by the block header stake bits which indicate the target stake difficulty (aka ticket price) as claimed.

func CheckProofOfWork deprecated

func CheckProofOfWork(header *wire.BlockHeader, powLimit *big.Int) error

CheckProofOfWork ensures the block header bits which indicate the target difficulty is in min/max range and that the block hash is less than the target difficulty as claimed. This is equivalent to the function in the standalone package with the exception that that any error is converted to a RuleError.

Deprecated: Use standalone.CheckProofOfWork instead.

func CheckTransactionInputs

func CheckTransactionInputs(subsidyCache *standalone.SubsidyCache, tx *dcrutil.Tx, txHeight int64, view *UtxoViewpoint, checkFraudProof bool, chainParams *chaincfg.Params) (int64, error)

CheckTransactionInputs performs a series of checks on the inputs to a transaction to ensure they are valid. An example of some of the checks include verifying all inputs exist, ensuring the coinbase seasoning requirements are met, detecting double spends, validating all values and fees are in the legal range and the total output amount doesn't exceed the input amount, and verifying the signatures to prove the spender was the owner of the Decred and therefore allowed to spend them. As it checks the inputs, it also calculates the total fees for the transaction and returns that value.

NOTE: The transaction MUST have already been sanity checked with the CheckTransactionSanity function prior to calling this function.

func CheckTransactionSanity

func CheckTransactionSanity(tx *wire.MsgTx, params *chaincfg.Params) error

CheckTransactionSanity performs some preliminary checks on a transaction to ensure it is sane. These checks are context free.

func CoinbasePaysTax deprecated

func CoinbasePaysTax(subsidyCache *SubsidyCache, tx *dcrutil.Tx, height int64, voters uint16, params *chaincfg.Params) error

CoinbasePaysTax checks to see if a given block's coinbase correctly pays tax to the developer organization.

Deprecated: This will be removed in the next major version.

func CompactToBig deprecated

func CompactToBig(compact uint32) *big.Int

CompactToBig converts a compact representation of a whole number N to an unsigned 32-bit number. The representation is similar to IEEE754 floating point numbers.

Like IEEE754 floating point, there are three basic components: the sign, the exponent, and the mantissa. They are broken out as follows:

* the most significant 8 bits represent the unsigned base 256 exponent
* bit 23 (the 24th bit) represents the sign bit
* the least significant 23 bits represent the mantissa

-------------------------------------------------
|   Exponent     |    Sign    |    Mantissa     |
-------------------------------------------------
| 8 bits [31-24] | 1 bit [23] | 23 bits [22-00] |
-------------------------------------------------

The formula to calculate N is:

N = (-1^sign) * mantissa * 256^(exponent-3)

This compact form is only used in Decred to encode unsigned 256-bit numbers which represent difficulty targets, thus there really is not a need for a sign bit, but it is implemented here to stay consistent with bitcoind.

Deprecated: Use standalone.CompactToBig instead.

Example

This example demonstrates how to convert the compact "bits" in a block header which represent the target difficulty to a big integer and display it using the typical hex notation.

package main

import (
	"fmt"

	"github.com/decred/dcrd/blockchain"

	_ "github.com/decred/dcrd/database/ffldb"
)

func main() {
	// Convert the bits from block 300000 in the main Decred block chain.
	bits := uint32(419465580)
	targetDifficulty := blockchain.CompactToBig(bits)

	// Display it in hex.
	fmt.Printf("%064x\n", targetDifficulty.Bytes())

}
Output:

0000000000000000896c00000000000000000000000000000000000000000000

func ConvertUtxosToMinimalOutputs

func ConvertUtxosToMinimalOutputs(entry *UtxoEntry) []*stake.MinimalOutput

ConvertUtxosToMinimalOutputs converts the contents of a UTX to a series of minimal outputs. It does this so that these can be passed to stake subpackage functions, where they will be evaluated for correctness.

func CountP2SHSigOps

func CountP2SHSigOps(tx *dcrutil.Tx, isCoinBaseTx bool, isStakeBaseTx bool, view *UtxoViewpoint) (int, error)

CountP2SHSigOps returns the number of signature operations for all input transactions which are of the pay-to-script-hash type. This uses the precise, signature operation counting mechanism from the script engine which requires access to the input transaction scripts.

func CountSigOps

func CountSigOps(tx *dcrutil.Tx, isCoinBaseTx bool, isSSGen bool) int

CountSigOps returns the number of signature operations for all transaction input and output scripts in the provided transaction. This uses the quicker, but imprecise, signature operation counting mechanism from txscript.

func DisableLog deprecated

func DisableLog()

DisableLog disables all library log output. Logging output is disabled by default until UseLogger is called.

Deprecated: Use UseLogger(slog.Disabled) instead.

func HashMerkleBranches deprecated

func HashMerkleBranches(left *chainhash.Hash, right *chainhash.Hash) *chainhash.Hash

HashMerkleBranches takes two hashes, treated as the left and right tree nodes, and returns the hash of their concatenation. This is a helper function used to aid in the generation of a merkle tree.

Deprecated: Use standalone.CalcMerkleRoot instead.

func HashToBig deprecated

func HashToBig(hash *chainhash.Hash) *big.Int

HashToBig converts a chainhash.Hash into a big.Int that can be used to perform math comparisons.

Deprecated: Use standalone.HashToBig instead.

func IsCoinBase deprecated

func IsCoinBase(tx *dcrutil.Tx) bool

IsCoinBase determines whether or not a transaction is a coinbase. 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 IsCoinBaseTx in that it works with a higher level util transaction as opposed to a raw wire transaction.

Deprecated: Use standalone.IsCoinBaseTx instead.

func IsCoinBaseTx deprecated

func IsCoinBaseTx(msgTx *wire.MsgTx) bool

IsCoinBaseTx determines whether or not a transaction is a coinbase. 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.

Deprecated: Use standalone.IsCoinBaseTx instead.

func IsExpired

func IsExpired(tx *dcrutil.Tx, blockHeight int64) bool

IsExpired returns where or not the passed transaction is expired according to the given block height.

This function only differs from IsExpiredTx in that it works with a higher level util transaction as opposed to a raw wire transaction.

func IsExpiredTx

func IsExpiredTx(tx *wire.MsgTx, blockHeight int64) bool

IsExpiredTx returns where or not the passed transaction is expired according to the given block height.

This function only differs from IsExpired in that it works with a raw wire transaction as opposed to a higher level util transaction.

func IsFinalizedTransaction

func IsFinalizedTransaction(tx *dcrutil.Tx, blockHeight int64, blockTime time.Time) bool

IsFinalizedTransaction determines whether or not a transaction is finalized.

func LockTimeToSequence

func LockTimeToSequence(isSeconds bool, lockTime uint32) (uint32, error)

LockTimeToSequence converts the passed relative lock time to a sequence number in accordance with DCP0003.

A sequence number is defined as follows:

- bit 31 is the disable bit
- the next 8 bits are reserved
- bit 22 is the relative lock type (unset = block height, set = seconds)
- the next 6 bites are reserved
- the least significant 16 bits represent the value
  - value has a granularity of 512 when interpreted as seconds (bit 22 set)

---------------------------------------------------
| Disable | Reserved |  Type | Reserved |  Value  |
---------------------------------------------------
|  1 bit  |  8 bits  | 1 bit |  6 bits  | 16 bits |
---------------------------------------------------
|   [31]  |  [30-23] |  [22] |  [21-16] | [15-0]  |
---------------------------------------------------

The above implies that the maximum relative block height that can be encoded is 65535 and the maximum relative number of seconds that can be encoded is 65535*512 = 33,553,920 seconds (~1.06 years). It also means that seconds are truncated to the nearest granularity towards 0 (e.g. 536 seconds will end up round tripping as 512 seconds and 1500 seconds will end up round tripping as 1024 seconds).

An error will be returned for values that are larger than can be represented.

func SequenceLockActive

func SequenceLockActive(lock *SequenceLock, blockHeight int64, medianTime time.Time) bool

SequenceLockActive determines if all of the inputs to a given transaction have achieved a relative age that surpasses the requirements specified by their respective sequence locks as calculated by CalcSequenceLock. A single sequence lock is sufficient because the calculated lock selects the minimum required time and block height from all of the non-disabled inputs after which the transaction can be included.

func UseLogger

func UseLogger(logger slog.Logger)

UseLogger uses a specified Logger to output package logging info.

func ValidateTransactionScripts

func ValidateTransactionScripts(tx *dcrutil.Tx, utxoView *UtxoViewpoint, flags txscript.ScriptFlags, sigCache *txscript.SigCache) error

ValidateTransactionScripts validates the scripts for the passed transaction using multiple goroutines.

Types

type AssertError

type AssertError string

AssertError identifies an error that indicates an internal code consistency issue and should be treated as a critical and unrecoverable error.

func (AssertError) Error

func (e AssertError) Error() string

Error returns the assertion error as a huma-readable string and satisfies the error interface.

type BehaviorFlags

type BehaviorFlags uint32

BehaviorFlags is a bitmask defining tweaks to the normal behavior when performing chain processing and consensus rules checks.

const (
	// BFFastAdd may be set to indicate that several checks can be avoided
	// for the block since it is already known to fit into the chain due to
	// already proving it correct links into the chain up to a known
	// checkpoint.  This is primarily used for headers-first mode.
	BFFastAdd BehaviorFlags = 1 << iota

	// BFNoPoWCheck may be set to indicate the proof of work check which
	// ensures a block hashes to a value less than the required target will
	// not be performed.
	BFNoPoWCheck

	// BFNone is a convenience value to specifically indicate no flags.
	BFNone BehaviorFlags = 0
)

type BestState

type BestState struct {
	Hash               chainhash.Hash   // The hash of the block.
	PrevHash           chainhash.Hash   // The previous block hash.
	Height             int64            // The height of the block.
	Bits               uint32           // The difficulty bits of the block.
	NextPoolSize       uint32           // The ticket pool size.
	NextStakeDiff      int64            // The next stake difficulty.
	BlockSize          uint64           // The size of the block.
	NumTxns            uint64           // The number of txns in the block.
	TotalTxns          uint64           // The total number of txns in the chain.
	MedianTime         time.Time        // Median time as per CalcPastMedianTime.
	TotalSubsidy       int64            // The total subsidy for the chain.
	NextWinningTickets []chainhash.Hash // The eligible tickets to vote on the next block.
	MissedTickets      []chainhash.Hash // The missed tickets set to be revoked.
	NextFinalState     [6]byte          // The calculated state of the lottery for the next block.
}

BestState houses information about the current best block and other info related to the state of the main chain as it exists from the point of view of the current best block.

The BestSnapshot method can be used to obtain access to this information in a concurrent safe manner and the data will not be changed out from under the caller when chain state changes occur as the function name implies. However, the returned snapshot must be treated as immutable since it is shared by all callers.

type BlockAcceptedNtfnsData

type BlockAcceptedNtfnsData struct {
	// BestHeight is the height of the current best chain.  Since the accepted
	// block might be on a side chain, this is not necessarily the same as the
	// height of the accepted block.
	BestHeight int64

	// ForkLen is the length of the side chain the block extended or zero in the
	// case the block extended the main chain.
	//
	// This can be used in conjunction with the height of the accepted block to
	// determine the height at which the side chain the block created or
	// extended forked from the best chain.
	ForkLen int64

	// Block is the block that was accepted into the chain.
	Block *dcrutil.Block
}

BlockAcceptedNtfnsData is the structure for data indicating information about an accepted block. Note that this does not necessarily mean the block that was accepted extended the best chain as it might have created or extended a side chain.

type BlockChain

type BlockChain struct {
	// contains filtered or unexported fields
}

BlockChain provides functions for working with the Decred block chain. It includes functionality such as rejecting duplicate blocks, ensuring blocks follow all rules, orphan handling, checkpoint handling, and best chain selection with reorganization.

func New

func New(config *Config) (*BlockChain, error)

New returns a BlockChain instance using the provided configuration details.

func (*BlockChain) BestPrevHash

func (b *BlockChain) BestPrevHash() chainhash.Hash

BestPrevHash returns the hash of the previous block of the block at HEAD.

This function is safe for concurrent access.

func (*BlockChain) BestSnapshot

func (b *BlockChain) BestSnapshot() *BestState

BestSnapshot returns information about the current best chain block and related state as of the current point in time. The returned instance must be treated as immutable since it is shared by all callers.

This function is safe for concurrent access.

func (*BlockChain) BlockByHash

func (b *BlockChain) BlockByHash(hash *chainhash.Hash) (*dcrutil.Block, error)

BlockByHash searches the internal chain block stores and the database in an attempt to find the requested block and returns it. This function returns blocks regardless of whether or not they are part of the main chain.

This function is safe for concurrent access.

func (*BlockChain) BlockByHeight

func (b *BlockChain) BlockByHeight(height int64) (*dcrutil.Block, error)

BlockByHeight returns the block at the given height in the main chain.

This function is safe for concurrent access.

func (*BlockChain) BlockHashByHeight

func (b *BlockChain) BlockHashByHeight(height int64) (*chainhash.Hash, error)

BlockHashByHeight returns the hash of the block at the given height in the main chain.

This function is safe for concurrent access.

func (*BlockChain) BlockHeightByHash

func (b *BlockChain) BlockHeightByHash(hash *chainhash.Hash) (int64, error)

BlockHeightByHash returns the height of the block with the given hash in the main chain.

This function is safe for concurrent access.

func (*BlockChain) BlockLocatorFromHash

func (b *BlockChain) BlockLocatorFromHash(hash *chainhash.Hash) BlockLocator

BlockLocatorFromHash returns a block locator for the passed block hash. See BlockLocator for details on the algorithm used to create a block locator.

In addition to the general algorithm referenced above, this function will return the block locator for the latest known tip of the main (best) chain if the passed hash is not currently known.

This function is safe for concurrent access.

func (*BlockChain) CalcNextRequiredDiffFromNode

func (b *BlockChain) CalcNextRequiredDiffFromNode(hash *chainhash.Hash, timestamp time.Time) (uint32, error)

CalcNextRequiredDiffFromNode calculates the required difficulty for the block given with the passed hash along with the given timestamp.

This function is NOT safe for concurrent access.

func (*BlockChain) CalcNextRequiredDifficulty

func (b *BlockChain) CalcNextRequiredDifficulty(timestamp time.Time) (uint32, error)

CalcNextRequiredDifficulty calculates the required difficulty for the block after the end of the current best chain based on the difficulty retarget rules.

This function is safe for concurrent access.

func (*BlockChain) CalcNextRequiredStakeDifficulty

func (b *BlockChain) CalcNextRequiredStakeDifficulty() (int64, error)

CalcNextRequiredStakeDifficulty calculates the required stake difficulty for the block after the end of the current best chain based on the active stake difficulty retarget rules.

This function is safe for concurrent access.

func (*BlockChain) CalcSequenceLock

func (b *BlockChain) CalcSequenceLock(tx *dcrutil.Tx, view *UtxoViewpoint) (*SequenceLock, error)

CalcSequenceLock computes the minimum block height and time after which the passed transaction can be included into a block while satisfying the relative lock times of all of its input sequence numbers. The passed view is used to obtain the past median time and block heights of the blocks in which the referenced outputs of the inputs to the transaction were included. The generated sequence lock can be used in conjunction with a block height and median time to determine if all inputs to the transaction have reached the required maturity allowing it to be included in a block.

NOTE: This will calculate the sequence locks regardless of the state of the agenda which conditionally activates it. This is acceptable for standard transactions, however, callers which are intending to perform any type of consensus checking must check the status of the agenda first.

This function is safe for concurrent access.

func (*BlockChain) CalcStakeVersionByHash

func (b *BlockChain) CalcStakeVersionByHash(hash *chainhash.Hash) (uint32, error)

CalcStakeVersionByHash calculates the expected stake version for the block AFTER provided block hash.

This function is safe for concurrent access.

func (*BlockChain) CalcWantHeight

func (b *BlockChain) CalcWantHeight(interval, height int64) int64

CalcWantHeight calculates the height of the final block of the previous interval given a block height.

func (*BlockChain) ChainTips

func (b *BlockChain) ChainTips() []ChainTipInfo

ChainTips returns information, in JSON-RPC format, about all of the currently known chain tips in the block index.

func (*BlockChain) ChainWork added in v1.1.0

func (b *BlockChain) ChainWork(hash *chainhash.Hash) (*big.Int, error)

ChainWork returns the total work up to and including the block of the provided block hash.

func (*BlockChain) CheckConnectBlockTemplate

func (b *BlockChain) CheckConnectBlockTemplate(block *dcrutil.Block) error

CheckConnectBlockTemplate fully validates that connecting the passed block to either the tip of the main chain or its parent does not violate any consensus rules, aside from the proof of work requirement. The block must connect to the current tip of the main chain or its parent.

This function is safe for concurrent access.

func (*BlockChain) CheckExpiredTicket

func (b *BlockChain) CheckExpiredTicket(hash chainhash.Hash) bool

CheckExpiredTicket returns whether or not a ticket was ever expired.

This function is safe for concurrent access.

func (*BlockChain) CheckExpiredTickets

func (b *BlockChain) CheckExpiredTickets(hashes []chainhash.Hash) []bool

CheckExpiredTickets returns whether or not a ticket in a slice of tickets was ever expired.

This function is safe for concurrent access.

func (*BlockChain) CheckLiveTicket

func (b *BlockChain) CheckLiveTicket(hash chainhash.Hash) bool

CheckLiveTicket returns whether or not a ticket exists in the live ticket treap of the best node.

This function is safe for concurrent access.

func (*BlockChain) CheckLiveTickets

func (b *BlockChain) CheckLiveTickets(hashes []chainhash.Hash) []bool

CheckLiveTickets returns whether or not a slice of tickets exist in the live ticket treap of the best node.

This function is safe for concurrent access.

func (*BlockChain) CheckMissedTickets

func (b *BlockChain) CheckMissedTickets(hashes []chainhash.Hash) []bool

CheckMissedTickets returns a slice of bools representing whether each ticket hash has been missed in the live ticket treap of the best node.

This function is safe for concurrent access.

func (*BlockChain) Checkpoints

func (b *BlockChain) Checkpoints() []chaincfg.Checkpoint

Checkpoints returns a slice of checkpoints (regardless of whether they are already known). When checkpoints are disabled or there are no checkpoints for the active network, it will return nil.

This function is safe for concurrent access.

func (*BlockChain) CountVoteVersion

func (b *BlockChain) CountVoteVersion(version uint32) (uint32, error)

CountVoteVersion returns the total number of version votes for the current rule change activation interval.

This function is safe for concurrent access.

func (*BlockChain) DisableCheckpoints

func (b *BlockChain) DisableCheckpoints(disable bool)

DisableCheckpoints provides a mechanism to disable validation against checkpoints which you DO NOT want to do in production. It is provided only for debug purposes.

This function is safe for concurrent access.

func (*BlockChain) DisableVerify

func (b *BlockChain) DisableVerify(disable bool)

DisableVerify provides a mechanism to disable transaction script validation which you DO NOT want to do in production as it could allow double spends and other undesirable things. It is provided only for debug purposes since script validation is extremely intensive and when debugging it is sometimes nice to quickly get the chain.

This function is safe for concurrent access.

func (*BlockChain) EstimateNextStakeDifficulty

func (b *BlockChain) EstimateNextStakeDifficulty(newTickets int64, useMaxTickets bool) (int64, error)

EstimateNextStakeDifficulty estimates the next stake difficulty by pretending the provided number of tickets will be purchased in the remainder of the interval unless the flag to use max tickets is set in which case it will use the max possible number of tickets that can be purchased in the remainder of the interval.

This function is safe for concurrent access.

func (*BlockChain) FetchSubsidyCache

func (b *BlockChain) FetchSubsidyCache() *SubsidyCache

FetchSubsidyCache returns the current subsidy cache from the blockchain.

This function is safe for concurrent access.

func (*BlockChain) FetchUtxoEntry

func (b *BlockChain) FetchUtxoEntry(txHash *chainhash.Hash) (*UtxoEntry, error)

FetchUtxoEntry loads and returns the unspent transaction output entry for the passed hash from the point of view of the end of the main chain.

NOTE: Requesting a hash for which there is no data will NOT return an error. Instead both the entry and the error will be nil. This is done to allow pruning of fully spent transactions. In practice this means the caller must check if the returned entry is nil before invoking methods on it.

This function is safe for concurrent access however the returned entry (if any) is NOT.

func (*BlockChain) FetchUtxoView

func (b *BlockChain) FetchUtxoView(tx *dcrutil.Tx, includePrevRegularTxns bool) (*UtxoViewpoint, error)

FetchUtxoView loads utxo details about the input transactions referenced by the passed transaction from the point of view of the end of the main chain while taking into account whether or not the transactions in the regular tree of the block just prior should be included or not depending on the provided flag. It also attempts to fetch the utxo details for the transaction itself so the returned view can be examined for duplicate unspent transaction outputs.

This function is safe for concurrent access however the returned view is NOT.

func (*BlockChain) ForceHeadReorganization

func (b *BlockChain) ForceHeadReorganization(formerBest chainhash.Hash, newBest chainhash.Hash) error

ForceHeadReorganization forces a reorganization of the block chain to the block hash requested, so long as it matches up with the current organization of the best chain.

This function is safe for concurrent access.

func (*BlockChain) GetOrphanRoot

func (b *BlockChain) GetOrphanRoot(hash *chainhash.Hash) *chainhash.Hash

GetOrphanRoot returns the head of the chain for the provided hash from the map of orphan blocks.

This function is safe for concurrent access.

func (*BlockChain) GetStakeVersions

func (b *BlockChain) GetStakeVersions(hash *chainhash.Hash, count int32) ([]StakeVersions, error)

GetStakeVersions returns a cooked array of StakeVersions. We do this in order to not bloat memory by returning raw blocks.

func (*BlockChain) GetVoteCounts

func (b *BlockChain) GetVoteCounts(version uint32, deploymentID string) (VoteCounts, error)

GetVoteCounts returns the vote counts for the specified version and deployment identifier for the current rule change activation interval.

This function is safe for concurrent access.

func (*BlockChain) GetVoteInfo

func (b *BlockChain) GetVoteInfo(hash *chainhash.Hash, version uint32) (*VoteInfo, error)

GetVoteInfo returns information on consensus deployment agendas and their respective states at the provided hash, for the provided deployment version.

func (*BlockChain) HaveBlock

func (b *BlockChain) HaveBlock(hash *chainhash.Hash) (bool, error)

HaveBlock returns whether or not the chain instance has the block represented by the passed hash. This includes checking the various places a block can be like part of the main chain, on a side chain, or in the orphan pool.

This function is safe for concurrent access.

func (*BlockChain) HeaderByHash

func (b *BlockChain) HeaderByHash(hash *chainhash.Hash) (wire.BlockHeader, error)

HeaderByHash returns the block header identified by the given hash or an error if it doesn't exist. Note that this will return headers from both the main chain and any side chains.

This function is safe for concurrent access.

func (*BlockChain) HeaderByHeight

func (b *BlockChain) HeaderByHeight(height int64) (wire.BlockHeader, error)

HeaderByHeight returns the block header at the given height in the main chain.

This function is safe for concurrent access.

func (*BlockChain) HeightRange

func (b *BlockChain) HeightRange(startHeight, endHeight int64) ([]chainhash.Hash, error)

HeightRange returns a range of block hashes for the given start and end heights. It is inclusive of the start height and exclusive of the end height. In other words, it is the half open range [startHeight, endHeight).

The end height will be limited to the current main chain height.

This function is safe for concurrent access.

func (*BlockChain) IsCheckpointCandidate

func (b *BlockChain) IsCheckpointCandidate(block *dcrutil.Block) (bool, error)

IsCheckpointCandidate returns whether or not the passed block is a good checkpoint candidate.

The factors used to determine a good checkpoint are:

- The block must be in the main chain
- The block must be at least 'CheckpointConfirmations' blocks prior to the
  current end of the main chain
- The timestamps for the blocks before and after the checkpoint must have
  timestamps which are also before and after the checkpoint, respectively
  (due to the median time allowance this is not always the case)
- The block must not contain any strange transaction such as those with
  nonstandard scripts

The intent is that candidates are reviewed by a developer to make the final decision and then manually added to the list of checkpoints for a network.

This function is safe for concurrent access.

func (*BlockChain) IsCurrent

func (b *BlockChain) IsCurrent() bool

IsCurrent returns whether or not the chain believes it is current. Several factors are used to guess, but the key factors that allow the chain to believe it is current are:

- Latest block height is after the latest checkpoint (if enabled)
- Latest block has a timestamp newer than 24 hours ago

This function is safe for concurrent access.

func (*BlockChain) IsFixSeqLocksAgendaActive added in v1.2.0

func (b *BlockChain) IsFixSeqLocksAgendaActive() (bool, error)

IsFixSeqLocksAgendaActive returns whether or not whether or not the fix sequence locks agenda vote, as defined in DCP0004 has passed and is now active for the block AFTER the current best chain block.

This function is safe for concurrent access.

func (*BlockChain) IsKnownOrphan

func (b *BlockChain) IsKnownOrphan(hash *chainhash.Hash) bool

IsKnownOrphan returns whether the passed hash is currently a known orphan. Keep in mind that only a limited number of orphans are held onto for a limited amount of time, so this function must not be used as an absolute way to test if a block is an orphan block. A full block (as opposed to just its hash) must be passed to ProcessBlock for that purpose. However, calling ProcessBlock with an orphan that already exists results in an error, so this function provides a mechanism for a caller to intelligently detect *recent* duplicate orphans and react accordingly.

This function is safe for concurrent access.

func (*BlockChain) IsLNFeaturesAgendaActive

func (b *BlockChain) IsLNFeaturesAgendaActive() (bool, error)

IsLNFeaturesAgendaActive returns whether or not the LN features agenda vote, as defined in DCP0002 and DCP0003 has passed and is now active for the block AFTER the current best chain block.

This function is safe for concurrent access.

func (*BlockChain) LatestBlockLocator

func (b *BlockChain) LatestBlockLocator() (BlockLocator, error)

LatestBlockLocator returns a block locator for the latest known tip of the main (best) chain.

This function is safe for concurrent access.

func (*BlockChain) LatestCheckpoint

func (b *BlockChain) LatestCheckpoint() *chaincfg.Checkpoint

LatestCheckpoint returns the most recent checkpoint (regardless of whether it is already known). When checkpoints are disabled or there are no checkpoints for the active network, it will return nil.

This function is safe for concurrent access.

func (*BlockChain) LiveTickets

func (b *BlockChain) LiveTickets() ([]chainhash.Hash, error)

LiveTickets returns all currently live tickets from the stake database.

This function is NOT safe for concurrent access.

func (*BlockChain) LocateBlocks

func (b *BlockChain) LocateBlocks(locator BlockLocator, hashStop *chainhash.Hash, maxHashes uint32) []chainhash.Hash

LocateBlocks returns the hashes of the blocks after the first known block in the locator until the provided stop hash is reached, or up to the provided max number of block hashes.

In addition, there are two special cases:

- When no locators are provided, the stop hash is treated as a request for

that block, so it will either return the stop hash itself if it is known,
or nil if it is unknown

- When locators are provided, but none of them are known, hashes starting

after the genesis block will be returned

This function is safe for concurrent access.

func (*BlockChain) LocateHeaders

func (b *BlockChain) LocateHeaders(locator BlockLocator, hashStop *chainhash.Hash) []wire.BlockHeader

LocateHeaders returns the headers of the blocks after the first known block in the locator until the provided stop hash is reached, or up to a max of wire.MaxBlockHeadersPerMsg headers.

In addition, there are two special cases:

- When no locators are provided, the stop hash is treated as a request for

that header, so it will either return the header for the stop hash itself
if it is known, or nil if it is unknown

- When locators are provided, but none of them are known, headers starting

after the genesis block will be returned

This function is safe for concurrent access.

func (*BlockChain) LotteryDataForBlock

func (b *BlockChain) LotteryDataForBlock(hash *chainhash.Hash) ([]chainhash.Hash, int, [6]byte, error)

LotteryDataForBlock returns lottery data for a given block in the block chain, including side chain blocks.

It is safe for concurrent access.

func (*BlockChain) MainChainHasBlock

func (b *BlockChain) MainChainHasBlock(hash *chainhash.Hash) bool

MainChainHasBlock returns whether or not the block with the given hash is in the main chain.

This function is safe for concurrent access.

func (*BlockChain) MaxBlockSize

func (b *BlockChain) MaxBlockSize() (int64, error)

MaxBlockSize returns the maximum permitted block size for the block AFTER the end of the current best chain.

This function is safe for concurrent access.

func (*BlockChain) MissedTickets

func (b *BlockChain) MissedTickets() ([]chainhash.Hash, error)

MissedTickets returns all currently missed tickets from the stake database.

This function is NOT safe for concurrent access.

func (*BlockChain) NextLotteryData

func (b *BlockChain) NextLotteryData() ([]chainhash.Hash, int, [6]byte, error)

NextLotteryData returns the next tickets eligible for spending as SSGen on the top block. It also returns the ticket pool size and the PRNG state checksum.

This function is safe for concurrent access.

func (*BlockChain) NextThresholdState added in v1.1.0

func (b *BlockChain) NextThresholdState(hash *chainhash.Hash, version uint32, deploymentID string) (ThresholdStateTuple, error)

NextThresholdState returns the current rule change threshold state of the given deployment ID for the block AFTER the provided block hash.

This function is safe for concurrent access.

func (*BlockChain) ProcessBlock

func (b *BlockChain) ProcessBlock(block *dcrutil.Block, flags BehaviorFlags) (int64, bool, error)

ProcessBlock is the main workhorse for handling insertion of new blocks into the block chain. It includes functionality such as rejecting duplicate blocks, ensuring blocks follow all rules, orphan handling, and insertion into the block chain along with best chain selection and reorganization.

When no errors occurred during processing, the first return value indicates the length of the fork the block extended. In the case it either exteneded the best chain or is now the tip of the best chain due to causing a reorganize, the fork length will be 0. The second return value indicates whether or not the block is an orphan, in which case the fork length will also be zero as expected, because it, by definition, does not connect ot the best chain.

This function is safe for concurrent access.

Example

This example demonstrates how to create a new chain instance and use ProcessBlock to attempt to attempt add a block to the chain. As the package overview documentation describes, this includes all of the Decred consensus rules. This example intentionally attempts to insert a duplicate genesis block to illustrate how an invalid block is handled.

package main

import (
	"fmt"
	"os"
	"path/filepath"

	"github.com/decred/dcrd/blockchain"
	"github.com/decred/dcrd/chaincfg"
	"github.com/decred/dcrd/database"
	"github.com/decred/dcrd/dcrutil"

	_ "github.com/decred/dcrd/database/ffldb"
)

func main() {
	// Create a new database to store the accepted blocks into.  Typically
	// this would be opening an existing database and would not be deleting
	// and creating a new database like this, but it is done here so this is
	// a complete working example and does not leave temporary files laying
	// around.
	dbPath := filepath.Join(os.TempDir(), "exampleprocessblock")
	_ = os.RemoveAll(dbPath)
	db, err := database.Create("ffldb", dbPath, chaincfg.MainNetParams.Net)
	if err != nil {
		fmt.Printf("Failed to create database: %v\n", err)
		return
	}
	defer os.RemoveAll(dbPath)
	defer db.Close()

	// Create a new BlockChain instance using the underlying database for
	// the main bitcoin network.  This example does not demonstrate some
	// of the other available configuration options such as specifying a
	// notification callback and signature cache.  Also, the caller would
	// ordinarily keep a reference to the median time source and add time
	// values obtained from other peers on the network so the local time is
	// adjusted to be in agreement with other peers.
	chain, err := blockchain.New(&blockchain.Config{
		DB:          db,
		ChainParams: &chaincfg.MainNetParams,
		TimeSource:  blockchain.NewMedianTime(),
	})
	if err != nil {
		fmt.Printf("Failed to create chain instance: %v\n", err)
		return
	}

	// Process a block.  For this example, we are going to intentionally
	// cause an error by trying to process the genesis block which already
	// exists.
	genesisBlock := dcrutil.NewBlock(chaincfg.MainNetParams.GenesisBlock)
	forkLen, isOrphan, err := chain.ProcessBlock(genesisBlock,
		blockchain.BFNone)
	if err != nil {
		fmt.Printf("Failed to create chain instance: %v\n", err)
		return
	}
	isMainChain := !isOrphan && forkLen == 0
	fmt.Printf("Block accepted. Is it on the main chain?: %v", isMainChain)
	fmt.Printf("Block accepted. Is it an orphan?: %v", isOrphan)

	// This output is dependent on the genesis block, and needs to be
	// updated if the mainnet genesis block is updated.
	
Output:

func (*BlockChain) StateLastChangedHeight added in v1.1.0

func (b *BlockChain) StateLastChangedHeight(hash *chainhash.Hash, version uint32, deploymentID string) (int64, error)

StateLastChangedHeight returns the height at which the provided consensus deployment agenda last changed state. Note that, unlike the ThresholdState function, this function returns the information as of the passed block hash.

This function is safe for concurrent access.

func (*BlockChain) TicketPoolValue

func (b *BlockChain) TicketPoolValue() (dcrutil.Amount, error)

TicketPoolValue returns the current value of all the locked funds in the ticket pool.

This function is safe for concurrent access. All live tickets are at least 256 blocks deep on mainnet, so the UTXO set should generally always have the asked for transactions.

func (*BlockChain) TicketsWithAddress

func (b *BlockChain) TicketsWithAddress(address dcrutil.Address) ([]chainhash.Hash, error)

TicketsWithAddress returns a slice of ticket hashes that are currently live corresponding to the given address.

This function is safe for concurrent access.

func (*BlockChain) TipGeneration

func (b *BlockChain) TipGeneration() ([]chainhash.Hash, error)

TipGeneration returns the entire generation of blocks stemming from the parent of the current tip.

The function is safe for concurrent access.

func (*BlockChain) TotalSubsidy

func (b *BlockChain) TotalSubsidy() int64

TotalSubsidy returns the total subsidy mined so far in the best chain.

This function is safe for concurrent access.

type BlockLocator

type BlockLocator []*chainhash.Hash

BlockLocator is used to help locate a specific block. The algorithm for building the block locator is to add the hashes in reverse order until the genesis block is reached. In order to keep the list of locator hashes to a reasonable number of entries, first the most recent previous 12 block hashes are added, then the step is doubled each loop iteration to exponentially decrease the number of hashes as a function of the distance from the block being located.

For example, assume a block chain with a side chain as depicted below:

genesis -> 1 -> 2 -> ... -> 15 -> 16  -> 17  -> 18
                              \-> 16a -> 17a

The block locator for block 17a would be the hashes of blocks: [17a 16a 15 14 13 12 11 10 9 8 7 6 4 genesis]

type ChainTipInfo added in v1.1.0

type ChainTipInfo struct {
	// Height specifies the block height of the chain tip.
	Height int64

	// Hash specifies the block hash of the chain tip.
	Hash chainhash.Hash

	// BranchLen specifies the length of the branch that connects the chain tip
	// to the main chain.  It will be zero for the main chain tip.
	BranchLen int64

	// Status specifies the validation status of chain formed by the chain tip.
	//
	// active:
	//   The current best chain tip.
	//
	// invalid:
	//   The block or one of its ancestors is invalid.
	//
	// headers-only:
	//   The block or one of its ancestors does not have the full block data
	//   available which also means the block can't be validated or connected.
	//
	// valid-fork:
	//   The block is fully validated which implies it was probably part of the
	//   main chain at one point and was reorganized.
	//
	// valid-headers:
	//   The full block data is available and the header is valid, but the block
	//   was never validated which implies it was probably never part of the
	//   main chain.
	Status string
}

ChainTipInfo models information about a chain tip.

type Config

type Config struct {
	// DB defines the database which houses the blocks and will be used to
	// store all metadata created by this package such as the utxo set.
	//
	// This field is required.
	DB database.DB

	// Interrupt specifies a channel the caller can close to signal that
	// long running operations, such as catching up indexes or performing
	// database migrations, should be interrupted.
	//
	// This field can be nil if the caller does not desire the behavior.
	Interrupt <-chan struct{}

	// ChainParams identifies which chain parameters the chain is associated
	// with.
	//
	// This field is required.
	ChainParams *chaincfg.Params

	// TimeSource defines the median time source to use for things such as
	// block processing and determining whether or not the chain is current.
	//
	// The caller is expected to keep a reference to the time source as well
	// and add time samples from other peers on the network so the local
	// time is adjusted to be in agreement with other peers.
	TimeSource MedianTimeSource

	// Notifications defines a callback to which notifications will be sent
	// when various events take place.  See the documentation for
	// Notification and NotificationType for details on the types and
	// contents of notifications.
	//
	// This field can be nil if the caller is not interested in receiving
	// notifications.
	Notifications NotificationCallback

	// SigCache defines a signature cache to use when when validating
	// signatures.  This is typically most useful when individual
	// transactions are already being validated prior to their inclusion in
	// a block such as what is usually done via a transaction memory pool.
	//
	// This field can be nil if the caller is not interested in using a
	// signature cache.
	SigCache *txscript.SigCache

	// IndexManager defines an index manager to use when initializing the
	// chain and connecting and disconnecting blocks.
	//
	// This field can be nil if the caller does not wish to make use of an
	// index manager.
	IndexManager IndexManager
}

Config is a descriptor which specifies the blockchain instance configuration.

type DeploymentError

type DeploymentError string

DeploymentError identifies an error that indicates a deployment ID was specified that does not exist.

func (DeploymentError) Error

func (e DeploymentError) Error() string

Error returns the assertion error as a human-readable string and satisfies the error interface.

type DuplicateDeploymentError added in v1.2.0

type DuplicateDeploymentError string

DuplicateDeploymentError identifies an error that indicates a duplicate deployment ID was specified in the network parameter deployment definitions.

func (DuplicateDeploymentError) Error added in v1.2.0

func (e DuplicateDeploymentError) Error() string

Error returns the assertion error as a human-readable string and satisfies the error interface.

type ErrorCode

type ErrorCode int

ErrorCode identifies a kind of error.

const (
	// ErrDuplicateBlock indicates a block with the same hash already
	// exists.
	ErrDuplicateBlock ErrorCode = iota

	// ErrMissingParent indicates that the block was an orphan.
	ErrMissingParent

	// ErrBlockTooBig indicates the serialized block size exceeds the
	// maximum allowed size.
	ErrBlockTooBig

	// ErrWrongBlockSize indicates that the block size in the header is not
	// the actual serialized size of the block.
	ErrWrongBlockSize

	// ErrBlockVersionTooOld indicates the block version is too old and is
	// no longer accepted since the majority of the network has upgraded
	// to a newer version.
	ErrBlockVersionTooOld

	// ErrBadStakeVersionindicates the block version is too old and is no
	// longer accepted since the majority of the network has upgraded to a
	// newer version.
	ErrBadStakeVersion

	// ErrInvalidTime indicates the time in the passed block has a precision
	// that is more than one second.  The chain consensus rules require
	// timestamps to have a maximum precision of one second.
	ErrInvalidTime

	// ErrTimeTooOld indicates the time is either before the median time of
	// the last several blocks per the chain consensus rules or prior to the
	// most recent checkpoint.
	ErrTimeTooOld

	// ErrTimeTooNew indicates the time is too far in the future as compared
	// the current time.
	ErrTimeTooNew

	// ErrDifficultyTooLow indicates the difficulty for the block is lower
	// than the difficulty required by the most recent checkpoint.
	ErrDifficultyTooLow

	// ErrUnexpectedDifficulty indicates specified bits do not align with
	// the expected value either because it doesn't match the calculated
	// valued based on difficulty regarted rules or it is out of the valid
	// range.
	ErrUnexpectedDifficulty

	// ErrHighHash indicates the block does not hash to a value which is
	// lower than the required target difficultly.
	ErrHighHash

	// ErrBadMerkleRoot indicates the calculated merkle root does not match
	// the expected value.
	ErrBadMerkleRoot

	// ErrBadCheckpoint indicates a block that is expected to be at a
	// checkpoint height does not match the expected one.
	ErrBadCheckpoint

	// ErrForkTooOld indicates a block is attempting to fork the block chain
	// before the most recent checkpoint.
	ErrForkTooOld

	// ErrCheckpointTimeTooOld indicates a block has a timestamp before the
	// most recent checkpoint.
	ErrCheckpointTimeTooOld

	// ErrNoTransactions indicates the block does not have a least one
	// transaction.  A valid block must have at least the coinbase
	// transaction.
	ErrNoTransactions

	// ErrTooManyTransactions indicates the block has more transactions than
	// are allowed.
	ErrTooManyTransactions

	// ErrNoTxInputs indicates a transaction does not have any inputs.  A
	// valid transaction must have at least one input.
	ErrNoTxInputs

	// ErrNoTxOutputs indicates a transaction does not have any outputs.  A
	// valid transaction must have at least one output.
	ErrNoTxOutputs

	// ErrTxTooBig indicates a transaction exceeds the maximum allowed size
	// when serialized.
	ErrTxTooBig

	// ErrBadTxOutValue indicates an output value for a transaction is
	// invalid in some way such as being out of range.
	ErrBadTxOutValue

	// ErrDuplicateTxInputs indicates a transaction references the same
	// input more than once.
	ErrDuplicateTxInputs

	// ErrBadTxInput indicates a transaction input is invalid in some way
	// such as referencing a previous transaction outpoint which is out of
	// range or not referencing one at all.
	ErrBadTxInput

	// ErrMissingTxOut indicates a transaction output referenced by an input
	// either does not exist or has already been spent.
	ErrMissingTxOut

	// ErrUnfinalizedTx indicates a transaction has not been finalized.
	// A valid block may only contain finalized transactions.
	ErrUnfinalizedTx

	// ErrDuplicateTx indicates a block contains an identical transaction
	// (or at least two transactions which hash to the same value).  A
	// valid block may only contain unique transactions.
	ErrDuplicateTx

	// ErrOverwriteTx indicates a block contains a transaction that has
	// the same hash as a previous transaction which has not been fully
	// spent.
	ErrOverwriteTx

	// ErrImmatureSpend indicates a transaction is attempting to spend a
	// coinbase that has not yet reached the required maturity.
	ErrImmatureSpend

	// ErrSpendTooHigh indicates a transaction is attempting to spend more
	// value than the sum of all of its inputs.
	ErrSpendTooHigh

	// ErrBadFees indicates the total fees for a block are invalid due to
	// exceeding the maximum possible value.
	ErrBadFees

	// ErrTooManySigOps indicates the total number of signature operations
	// for a transaction or block exceed the maximum allowed limits.
	ErrTooManySigOps

	// ErrFirstTxNotCoinbase indicates the first transaction in a block
	// is not a coinbase transaction.
	ErrFirstTxNotCoinbase

	// ErrCoinbaseHeight indicates that the encoded height in the coinbase
	// is incorrect.
	ErrCoinbaseHeight

	// ErrMultipleCoinbases indicates a block contains more than one
	// coinbase transaction.
	ErrMultipleCoinbases

	// ErrStakeTxInRegularTree indicates a stake transaction was found in
	// the regular transaction tree.
	ErrStakeTxInRegularTree

	// ErrRegTxInStakeTree indicates that a regular transaction was found in
	// the stake transaction tree.
	ErrRegTxInStakeTree

	// ErrBadCoinbaseScriptLen indicates the length of the signature script
	// for a coinbase transaction is not within the valid range.
	ErrBadCoinbaseScriptLen

	// ErrBadCoinbaseValue indicates the amount of a coinbase value does
	// not match the expected value of the subsidy plus the sum of all fees.
	ErrBadCoinbaseValue

	// ErrBadCoinbaseOutpoint indicates that the outpoint used by a coinbase
	// as input was non-null.
	ErrBadCoinbaseOutpoint

	// ErrBadCoinbaseFraudProof indicates that the fraud proof for a coinbase
	// input was non-null.
	ErrBadCoinbaseFraudProof

	// ErrBadCoinbaseAmountIn indicates that the AmountIn (=subsidy) for a
	// coinbase input was incorrect.
	ErrBadCoinbaseAmountIn

	// ErrBadStakebaseAmountIn indicates that the AmountIn (=subsidy) for a
	// stakebase input was incorrect.
	ErrBadStakebaseAmountIn

	// ErrBadStakebaseScriptLen indicates the length of the signature script
	// for a stakebase transaction is not within the valid range.
	ErrBadStakebaseScriptLen

	// ErrBadStakebaseScrVal indicates the signature script for a stakebase
	// transaction was not set to the network consensus value.
	ErrBadStakebaseScrVal

	// ErrScriptMalformed indicates a transaction script is malformed in
	// some way.  For example, it might be longer than the maximum allowed
	// length or fail to parse.
	ErrScriptMalformed

	// ErrScriptValidation indicates the result of executing transaction
	// script failed.  The error covers any failure when executing scripts
	// such signature verification failures and execution past the end of
	// the stack.
	ErrScriptValidation

	// ErrNotEnoughStake indicates that there was for some SStx in a given block,
	// the given SStx did not have enough stake to meet the network target.
	ErrNotEnoughStake

	// ErrStakeBelowMinimum indicates that for some SStx in a given block,
	// the given SStx had an amount of stake below the minimum network target.
	ErrStakeBelowMinimum

	// ErrNonstandardStakeTx indicates that a block contained a stake tx that
	// was not one of the allowed types of a stake transactions.
	ErrNonstandardStakeTx

	// ErrNotEnoughVotes indicates that a block contained less than a majority
	// of voters.
	ErrNotEnoughVotes

	// ErrTooManyVotes indicates that a block contained more than the maximum
	// allowable number of votes.
	ErrTooManyVotes

	// ErrFreshStakeMismatch indicates that a block's header contained a different
	// number of SStx as compared to what was found in the block.
	ErrFreshStakeMismatch

	// ErrTooManySStxs indicates that more than the allowed number of SStx was
	// found in a block.
	ErrTooManySStxs

	// ErrInvalidEarlyStakeTx indicates that a tx type other than SStx was found
	// in the stake tx tree before the period when stake validation begins, or
	// before the stake tx type could possibly be included in the block.
	ErrInvalidEarlyStakeTx

	// ErrTicketUnavailable indicates that a vote in the block spent a ticket
	// that could not be found.
	ErrTicketUnavailable

	// ErrVotesOnWrongBlock indicates that an SSGen voted on a block not the
	// block's parent, and so was ineligible for inclusion into that block.
	ErrVotesOnWrongBlock

	// ErrVotesMismatch indicates that the number of SSGen in the block was not
	// equivalent to the number of votes provided in the block header.
	ErrVotesMismatch

	// ErrIncongruentVotebit indicates that the first votebit in votebits was not
	// the same as that determined by the majority of voters in the SSGen tx
	// included in the block.
	ErrIncongruentVotebit

	// ErrInvalidSSRtx indicates than an SSRtx in a block could not be found to
	// have a valid missed sstx input as per the stake ticket database.
	ErrInvalidSSRtx

	// ErrInvalidRevNum indicates that the number of revocations from the
	// header was not the same as the number of SSRtx included in the block.
	ErrRevocationsMismatch

	// ErrTooManyRevocations indicates more revocations were found in a block
	// than were allowed.
	ErrTooManyRevocations

	// ErrTicketCommitment indicates that a ticket commitment contains an amount
	// that does not coincide with the associated ticket input amount.
	ErrTicketCommitment

	// ErrInvalidVoteInput indicates that an input to a vote transaction is
	// either not a stake ticket submission or is not a supported version.
	ErrInvalidVoteInput

	// ErrBadNumPayees indicates that either a vote or revocation transaction
	// does not make the correct number of payments per the associated ticket
	// commitments.
	ErrBadNumPayees

	// ErrBadPayeeScriptVersion indicates that either a vote or revocation
	// transaction output that corresponds to a ticket commitment does not use
	// a supported script version.
	ErrBadPayeeScriptVersion

	// ErrBadPayeeScriptType indicates that either a vote or revocation
	// transaction output that corresponds to a ticket commitment does not pay
	// to the same script type required by the commitment.
	ErrBadPayeeScriptType

	// ErrBadPayeeScriptType indicates that either a vote or revocation
	// transaction output that corresponds to a ticket commitment does not pay
	// to the hash required by the commitment.
	ErrMismatchedPayeeHash

	// ErrBadPayeeValue indicates that either a vote or revocation transaction
	// output that corresponds to a ticket commitment does not pay the expected
	// amount required by the commitment.
	ErrBadPayeeValue

	// ErrSSGenSubsidy indicates that there was an error in the amount of subsidy
	// generated in the vote.
	ErrSSGenSubsidy

	// ErrImmatureTicketSpend indicates that a vote or revocation is attempting
	// to spend a ticket submission output that has not yet reached the required
	// maturity.
	ErrImmatureTicketSpend

	// ErrTicketInputScript indicates that a ticket input is not one of the
	// supported script forms or versions.
	ErrTicketInputScript

	// ErrInvalidRevokeInput indicates that an input to a revocation transaction
	// is either not a stake ticket submission or is not a supported version.
	ErrInvalidRevokeInput

	// ErrSSRtxPayees indicates that the SSRtx failed to pay out to the committed
	// addresses or amounts from the originating SStx.
	ErrSSRtxPayees

	// ErrTxSStxOutSpend indicates that a non SSGen or SSRtx tx attempted to spend
	// an OP_SSTX tagged output from an SStx.
	ErrTxSStxOutSpend

	// ErrRegTxCreateStakeOut indicates that a regular tx attempted to create
	// a stake tagged output.
	ErrRegTxCreateStakeOut

	// ErrInvalidFinalState indicates that the final state of the PRNG included
	// in the the block differed from the calculated final state.
	ErrInvalidFinalState

	// ErrPoolSize indicates an error in the ticket pool size for this block.
	ErrPoolSize

	// ErrForceReorgWrongChain indicates that a reroganization was attempted
	// to be forced, but the chain indicated was not mirrored by b.bestChain.
	ErrForceReorgWrongChain

	// ErrForceReorgMissingChild indicates that a reroganization was attempted
	// to be forced, but the child node to reorganize to could not be found.
	ErrForceReorgMissingChild

	// ErrBadStakebaseValue indicates that a block's stake tx tree has spent
	// more than it is allowed.
	ErrBadStakebaseValue

	// ErrDiscordantTxTree specifies that a given origin tx's content
	// indicated that it should exist in a different tx tree than the
	// one given in the TxIn outpoint.
	ErrDiscordantTxTree

	// ErrStakeFees indicates an error with the fees found in the stake
	// transaction tree.
	ErrStakeFees

	// ErrNoStakeTx indicates there were no stake transactions found in a
	// block after stake validation height.
	ErrNoStakeTx

	// ErrBadBlockHeight indicates that a block header's embedded block height
	// was different from where it was actually embedded in the block chain.
	ErrBadBlockHeight

	// ErrBlockOneTx indicates that block height 1 failed to correct generate
	// the block one premine transaction.
	ErrBlockOneTx

	// ErrBlockOneTx indicates that block height 1 coinbase transaction in
	// zero was incorrect in some way.
	ErrBlockOneInputs

	// ErrBlockOneOutputs indicates that block height 1 failed to incorporate
	// the ledger addresses correctly into the transaction's outputs.
	ErrBlockOneOutputs

	// ErrNoTax indicates that there was no tax present in the coinbase of a
	// block after height 1.
	ErrNoTax

	// ErrExpiredTx indicates that the transaction is currently expired.
	ErrExpiredTx

	// ErrExpiryTxSpentEarly indicates that an output from a transaction
	// that included an expiry field was spent before coinbase maturity
	// many blocks had passed in the blockchain.
	ErrExpiryTxSpentEarly

	// ErrFraudAmountIn indicates the witness amount given was fraudulent.
	ErrFraudAmountIn

	// ErrFraudBlockHeight indicates the witness block height given was
	// fraudulent.
	ErrFraudBlockHeight

	// ErrFraudBlockIndex indicates the witness block index given was
	// fraudulent.
	ErrFraudBlockIndex

	// ErrZeroValueOutputSpend indicates that a transaction attempted to spend a
	// zero value output.
	ErrZeroValueOutputSpend

	// ErrInvalidEarlyVoteBits indicates that a block before stake validation
	// height had an unallowed vote bits value.
	ErrInvalidEarlyVoteBits

	// ErrInvalidEarlyFinalState indicates that a block before stake validation
	// height had a non-zero final state.
	ErrInvalidEarlyFinalState

	// ErrKnownInvalidBlock indicates that this block has previously failed
	// validation.
	ErrKnownInvalidBlock

	// ErrInvalidAncestorBlock indicates that an ancestor of this block has
	// failed validation.
	ErrInvalidAncestorBlock

	// ErrInvalidTemplateParent indicates that a block template builds on a
	// block that is either not the current best chain tip or its parent.
	ErrInvalidTemplateParent
)

These constants are used to identify a specific RuleError.

func (ErrorCode) String

func (e ErrorCode) String() string

String returns the ErrorCode as a human-readable name.

type HashError

type HashError string

HashError identifies an error that indicates a hash was specified that does not exist.

func (HashError) Error

func (e HashError) Error() string

Error returns the error as a human-readable string and satisfies the error interface.

type IndexManager

type IndexManager interface {
	// Init is invoked during chain initialize in order to allow the index
	// manager to initialize itself and any indexes it is managing.  The
	// channel parameter specifies a channel the caller can close to signal
	// that the process should be interrupted.  It can be nil if that
	// behavior is not desired.
	Init(*BlockChain, <-chan struct{}) error

	// ConnectBlock is invoked when a new block has been connected to the
	// main chain.
	ConnectBlock(database.Tx, *dcrutil.Block, *dcrutil.Block, *UtxoViewpoint) error

	// DisconnectBlock is invoked when a block has been disconnected from
	// the main chain.
	DisconnectBlock(database.Tx, *dcrutil.Block, *dcrutil.Block, *UtxoViewpoint) error
}

IndexManager provides a generic interface that the is called when blocks are connected and disconnected to and from the tip of the main chain for the purpose of supporting optional indexes.

type MedianTimeSource

type MedianTimeSource interface {
	// AdjustedTime returns the current time adjusted by the median time
	// offset as calculated from the time samples added by AddTimeSample.
	AdjustedTime() time.Time

	// AddTimeSample adds a time sample that is used when determining the
	// median time of the added samples.
	AddTimeSample(id string, timeVal time.Time)

	// Offset returns the number of seconds to adjust the local clock based
	// upon the median of the time samples added by AddTimeData.
	Offset() time.Duration
}

MedianTimeSource provides a mechanism to add several time samples which are used to determine a median time which is then used as an offset to the local clock.

func NewMedianTime

func NewMedianTime() MedianTimeSource

NewMedianTime returns a new instance of concurrency-safe implementation of the MedianTimeSource interface. The returned implementation contains the rules necessary for proper time handling in the chain consensus rules and expects the time samples to be added from the timestamp field of the version message received from remote peers that successfully connect and negotiate.

type Notification

type Notification struct {
	Type NotificationType
	Data interface{}
}

Notification defines notification that is sent to the caller via the callback function provided during the call to New and consists of a notification type as well as associated data that depends on the type as follows:

	- NTNewTipBlockChecked:    *dcrutil.Block
	- NTBlockAccepted:         *BlockAcceptedNtfnsData
	- NTBlockConnected:        []*dcrutil.Block of len 2
	- NTBlockDisconnected:     []*dcrutil.Block of len 2
	- NTChainReorgStarted:     nil
	- NTChainReorgDone:        nil
 - NTReorganization:        *ReorganizationNtfnsData
 - NTSpentAndMissedTickets: *TicketNotificationsData
 - NTNewTickets:            *TicketNotificationsData

type NotificationCallback

type NotificationCallback func(*Notification)

NotificationCallback is used for a caller to provide a callback for notifications about various chain events.

type NotificationType

type NotificationType int

NotificationType represents the type of a notification message.

const (
	// NTNewTipBlockChecked indicates the associated block intends to extend
	// the current main chain and has passed all of the sanity and
	// contextual checks such as having valid proof of work, valid merkle
	// and stake roots, and only containing allowed votes and revocations.
	//
	// It should be noted that the block might still ultimately fail to
	// become the new main chain tip if it contains invalid scripts, double
	// spends, etc.  However, this is quite rare in practice because a lot
	// of work was expended to create a block which satisifies the proof of
	// work requirement.
	//
	// Finally, this notification is only sent if the the chain is believed
	// to be current and the chain lock is NOT released, so consumers must
	// take care to avoid calling blockchain functions to avoid potential
	// deadlock.
	//
	// Typically, a caller would want to use this notification to relay the
	// block to the rest of the network without needing to wait for the more
	// time consuming full connection to take place.
	NTNewTipBlockChecked NotificationType = iota

	// NTBlockAccepted indicates the associated block was accepted into
	// the block chain.  Note that this does not necessarily mean it was
	// added to the main chain.  For that, use NTBlockConnected.
	NTBlockAccepted

	// NTBlockConnected indicates the associated block was connected to the
	// main chain.
	NTBlockConnected

	// NTBlockDisconnected indicates the associated block was disconnected
	// from the main chain.
	NTBlockDisconnected

	// NTChainReorgStarted indicates that a chain reorganization has commenced.
	NTChainReorgStarted

	// NTChainReorgDone indicates that a chain reorganization has concluded.
	NTChainReorgDone

	// NTReorganization indicates that a blockchain reorganization has taken
	// place.
	NTReorganization

	// NTSpentAndMissedTickets indicates spent or missed tickets from a newly
	// accepted block.
	NTSpentAndMissedTickets

	// NTSpentAndMissedTickets indicates newly maturing tickets from a newly
	// accepted block.
	NTNewTickets
)

Constants for the type of a notification message.

func (NotificationType) String

func (n NotificationType) String() string

String returns the NotificationType in human-readable form.

type ReorganizationNtfnsData

type ReorganizationNtfnsData struct {
	OldHash   chainhash.Hash
	OldHeight int64
	NewHash   chainhash.Hash
	NewHeight int64
}

ReorganizationNtfnsData is the structure for data indicating information about a reorganization.

type RuleError

type RuleError struct {
	ErrorCode   ErrorCode // Describes the kind of error
	Description string    // Human readable description of the issue
}

RuleError identifies a rule violation. It is used to indicate that processing of a block or transaction failed due to one of the many validation rules. The caller can use type assertions to determine if a failure was specifically due to a rule violation and access the ErrorCode field to ascertain the specific reason for the rule violation.

func (RuleError) Error

func (e RuleError) Error() string

Error satisfies the error interface and prints human-readable errors.

type SequenceLock

type SequenceLock struct {
	MinHeight int64
	MinTime   int64
}

SequenceLock represents the minimum timestamp and minimum block height after which a transaction can be included into a block while satisfying the relative lock times of all of its input sequence numbers. It is calculated via the CalcSequenceLock function. Each field may be -1 if none of the input sequence numbers require a specific relative lock time for the respective type. Since all valid heights and times are larger than -1, this implies that it will not prevent a transaction from being included due to the sequence lock, which is the desired behavior.

type StakeVersions

type StakeVersions struct {
	Hash         chainhash.Hash
	Height       int64
	BlockVersion int32
	StakeVersion uint32
	Votes        []stake.VoteVersionTuple
}

StakeVersions is a condensed form of a dcrutil.Block that is used to prevent using gigabytes of memory.

type SubsidyCache deprecated

type SubsidyCache = standalone.SubsidyCache

SubsidyCache is a structure that caches calculated values of subsidy so that they're not constantly recalculated. The blockchain struct itself possesses a pointer to a preinitialized SubsidyCache.

Deprecated: Use standalone.SubsidyCache instead.

func NewSubsidyCache deprecated

func NewSubsidyCache(height int64, params *chaincfg.Params) *SubsidyCache

NewSubsidyCache initializes a new subsidy cache for a given height. It precalculates the values of the subsidy that are most likely to be seen by the client when it connects to the network.

Deprecated: Use standalone.NewSubsidyCache instead.

type ThresholdState

type ThresholdState byte

ThresholdState define the various threshold states used when voting on consensus changes.

const (
	// ThresholdDefined is the first state for each deployment and is the
	// state for the genesis block has by definition for all deployments.
	ThresholdDefined ThresholdState = 0

	// ThresholdStarted is the state for a deployment once its start time
	// has been reached.
	ThresholdStarted ThresholdState = 1

	// ThresholdLockedIn is the state for a deployment during the retarget
	// period which is after the ThresholdStarted state period and the
	// number of blocks that have voted for the deployment equal or exceed
	// the required number of votes for the deployment.
	ThresholdLockedIn ThresholdState = 2

	// ThresholdActive is the state for a deployment for all blocks after a
	// retarget period in which the deployment was in the ThresholdLockedIn
	// state.
	ThresholdActive ThresholdState = 3

	// ThresholdFailed is the state for a deployment once its expiration
	// time has been reached and it did not reach the ThresholdLockedIn
	// state.
	ThresholdFailed ThresholdState = 4

	// ThresholdInvalid is a deployment that does not exist.
	ThresholdInvalid ThresholdState = 5
)

These constants are used to identify specific threshold states.

NOTE: This section specifically does not use iota for the individual states since these values are serialized and must be stable for long-term storage.

func (ThresholdState) String

func (t ThresholdState) String() string

String returns the ThresholdState as a human-readable name.

type ThresholdStateTuple

type ThresholdStateTuple struct {
	// state contains the current ThresholdState.
	State ThresholdState

	// Choice is set to invalidChoice unless state is: ThresholdLockedIn,
	// ThresholdFailed & ThresholdActive.  choice should always be
	// crosschecked with invalidChoice.
	Choice uint32
}

ThresholdStateTuple contains the current state and the activated choice, when valid.

func (ThresholdStateTuple) String

func (t ThresholdStateTuple) String() string

String returns the ThresholdStateTuple as a human-readable tuple.

type TicketNotificationsData

type TicketNotificationsData struct {
	Hash            chainhash.Hash
	Height          int64
	StakeDifficulty int64
	TicketsSpent    []chainhash.Hash
	TicketsMissed   []chainhash.Hash
	TicketsNew      []chainhash.Hash
}

TicketNotificationsData is the structure for new/spent/missed ticket notifications at blockchain HEAD that are outgoing from chain.

type UtxoEntry

type UtxoEntry struct {
	// contains filtered or unexported fields
}

UtxoEntry contains contextual information about an unspent transaction such as whether or not it is a coinbase transaction, which block it was found in, and the spent status of its outputs.

The struct is aligned for memory efficiency.

func (*UtxoEntry) AmountByIndex

func (entry *UtxoEntry) AmountByIndex(outputIndex uint32) int64

AmountByIndex returns the amount of the provided output index.

Returns 0 if the output index references an output that does not exist either due to it being invalid or because the output is not part of the view due to previously being spent/pruned.

func (*UtxoEntry) BlockHeight

func (entry *UtxoEntry) BlockHeight() int64

BlockHeight returns the height of the block containing the transaction the utxo entry represents.

func (*UtxoEntry) BlockIndex

func (entry *UtxoEntry) BlockIndex() uint32

BlockIndex returns the height of the block containing the transaction the utxo entry represents.

func (*UtxoEntry) Clone

func (entry *UtxoEntry) Clone() *UtxoEntry

Clone returns a deep copy of the utxo entry.

func (*UtxoEntry) HasExpiry

func (entry *UtxoEntry) HasExpiry() bool

HasExpiry returns the transaction expiry for the transaction that the utxo entry represents.

func (*UtxoEntry) IsCoinBase

func (entry *UtxoEntry) IsCoinBase() bool

IsCoinBase returns whether or not the transaction the utxo entry represents is a coinbase.

func (*UtxoEntry) IsFullySpent

func (entry *UtxoEntry) IsFullySpent() bool

IsFullySpent returns whether or not the transaction the utxo entry represents is fully spent.

func (*UtxoEntry) IsOutputSpent

func (entry *UtxoEntry) IsOutputSpent(outputIndex uint32) bool

IsOutputSpent returns whether or not the provided output index has been spent based upon the current state of the unspent transaction output view the entry was obtained from.

Returns true if the output index references an output that does not exist either due to it being invalid or because the output is not part of the view due to previously being spent/pruned.

func (*UtxoEntry) PkScriptByIndex

func (entry *UtxoEntry) PkScriptByIndex(outputIndex uint32) []byte

PkScriptByIndex returns the public key script for the provided output index.

Returns nil if the output index references an output that does not exist either due to it being invalid or because the output is not part of the view due to previously being spent/pruned.

func (*UtxoEntry) ScriptVersionByIndex

func (entry *UtxoEntry) ScriptVersionByIndex(outputIndex uint32) uint16

ScriptVersionByIndex returns the public key script for the provided output index.

Returns 0 if the output index references an output that does not exist either due to it being invalid or because the output is not part of the view due to previously being spent/pruned.

func (*UtxoEntry) SpendOutput

func (entry *UtxoEntry) SpendOutput(outputIndex uint32)

SpendOutput marks the output at the provided index as spent. Specifying an output index that does not exist will not have any effect.

func (*UtxoEntry) TransactionType

func (entry *UtxoEntry) TransactionType() stake.TxType

TransactionType returns the transaction type of the transaction the utxo entry represents.

func (*UtxoEntry) TxVersion

func (entry *UtxoEntry) TxVersion() uint16

TxVersion returns the transaction version of the transaction the utxo represents.

type UtxoViewpoint

type UtxoViewpoint struct {
	// contains filtered or unexported fields
}

UtxoViewpoint represents a view into the set of unspent transaction outputs from a specific point of view in the chain. For example, it could be for the end of the main chain, some point in the history of the main chain, or down a side chain.

The unspent outputs are needed by other transactions for things such as script validation and double spend prevention.

func NewUtxoViewpoint

func NewUtxoViewpoint() *UtxoViewpoint

NewUtxoViewpoint returns a new empty unspent transaction output view.

func (*UtxoViewpoint) AddTxOuts

func (view *UtxoViewpoint) AddTxOuts(tx *dcrutil.Tx, blockHeight int64, blockIndex uint32)

AddTxOuts adds all outputs in the passed transaction which are not provably unspendable to the view. When the view already has entries for any of the outputs, they are simply marked unspent. All fields will be updated for existing entries since it's possible it has changed during a reorg.

func (*UtxoViewpoint) BestHash

func (view *UtxoViewpoint) BestHash() *chainhash.Hash

BestHash returns the hash of the best block in the chain the view currently respresents.

func (*UtxoViewpoint) Entries

func (view *UtxoViewpoint) Entries() map[chainhash.Hash]*UtxoEntry

Entries returns the underlying map that stores of all the utxo entries.

func (*UtxoViewpoint) LookupEntry

func (view *UtxoViewpoint) LookupEntry(txHash *chainhash.Hash) *UtxoEntry

LookupEntry returns information about a given transaction according to the current state of the view. It will return nil if the passed transaction hash does not exist in the view or is otherwise not available such as when it has been disconnected during a reorg.

func (*UtxoViewpoint) SetBestHash

func (view *UtxoViewpoint) SetBestHash(hash *chainhash.Hash)

SetBestHash sets the hash of the best block in the chain the view currently respresents.

type VoteCounts

type VoteCounts struct {
	Total        uint32
	TotalAbstain uint32
	VoteChoices  []uint32
}

VoteCounts is a compacted struct that is used to message vote counts.

type VoteInfo

type VoteInfo struct {
	Agendas      []chaincfg.ConsensusDeployment
	AgendaStatus []ThresholdStateTuple
}

VoteInfo represents information on agendas and their respective states for a consensus deployment.

type VoteVersionError

type VoteVersionError uint32

VoteVersionError identifies an error that indicates a vote version was specified that does not exist.

func (VoteVersionError) Error

func (e VoteVersionError) Error() string

Error returns the assertion error as a human-readable string and satisfies the error interface.

Directories

Path Synopsis
Package chaingen provides facilities for generating a full chain of blocks.
Package chaingen provides facilities for generating a full chain of blocks.
Package fullblocktests provides a set of block consensus validation tests.
Package fullblocktests provides a set of block consensus validation tests.
Package indexers implements optional block chain indexes.
Package indexers implements optional block chain indexes.
stake module
standalone module
internal
dbnamespace
Package dbnamespace contains constants that define the database namespaces for the purpose of the blockchain, so that external callers may easily access this data.
Package dbnamespace contains constants that define the database namespaces for the purpose of the blockchain, so that external callers may easily access this data.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL