btc

package
v0.6.3 Latest Latest
Warning

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

 Go to latest Published: Sep 7, 2023 License: BlueOak-1.0.0 Imports: 33 Imported by: 2

Documentation

Index

Constants

View Source 
const (
	BipID = 0

	BondVersion = 0
)
View Source 
const ErrReorgDetected = dex.ErrorKind("reorg detected")

Variables

This section is empty.

Functions

func LiveFeeRates 

func LiveFeeRates(btc *Backend, t *testing.T, standards map[string]uint64)

LiveFeeRates scans a mapping of txid -> fee rate checking that the backend returns the expected fee rate.

func LiveP2SHStats 

func LiveP2SHStats(btc *Backend, t *testing.T, numToDo int)

LiveP2SHStats will scan the provided Backend's node for inputs that spend pay-to-script-hash outputs. The pubkey scripts and redeem scripts are examined to ensure the backend understands what they are and can extract addresses. Ideally, the stats will show no scripts which were unparseable by the backend, but the presence of unknowns is not an error.

func LiveUTXOStats 

func LiveUTXOStats(btc *Backend, t *testing.T)

LiveUTXOStats will scan the provided Backend's node for transaction outputs. The outputs are requested with GetRawTransactionVerbose, and statistics collected regarding spendability and pubkey script types. This test does not request via the Backend.UTXO method and is not meant to cover that code. Instead, these tests check the backend's real-world blockchain literacy. Ideally, the stats will show no scripts which were unparseable by the backend, but the presence of unknowns is not an error.

func NewBackend 

func NewBackend(configPath string, logger dex.Logger, network dex.Network) (asset.Backend, error)

NewBackend is the exported constructor by which the DEX will import the backend. The configPath can be an empty string, in which case the standard system location of the bitcoind config file is assumed.

func ParseBondTx added in v0.6.0 

func ParseBondTx(ver uint16, msgTx *wire.MsgTx, chainParams *chaincfg.Params, segwit bool) (amt int64, bondAddr string,
	bondPubKeyHash []byte, lockTime int64, acct account.AccountID, err error)

ParseBondTx performs basic validation of a serialized time-locked fidelity bond transaction given the bond's P2SH or P2WSH redeem script.

The transaction must have at least two outputs: out 0 pays to a P2SH address (the bond), and out 1 is a nulldata output that commits to an account ID. There may also be a change output.

Returned: The bond's coin ID (i.e. encoded UTXO) of the bond output. The bond output's amount and P2SH/P2WSH address. The lockTime and pubkey hash data pushes from the script. The account ID from the second output is also returned.

Properly formed transactions:

  1. The bond output (vout 0) must be a P2SH/P2WSH output.
  2. The bond's redeem script must be of the form: <lockTime[4]> OP_CHECKLOCKTIMEVERIFY OP_DROP OP_DUP OP_HASH160 <pubkeyhash[20]> OP_EQUALVERIFY OP_CHECKSIG
  3. The null data output (vout 1) must have a 58-byte data push (ver | account ID | lockTime | pubkeyHash).
  4. The transaction must have a zero locktime and expiry.
  5. All inputs must have the max sequence num set (finalized).
  6. The transaction must pass the checks in the blockchain.CheckTransactionSanity function.

func TestMedianFees added in v0.5.0 

func TestMedianFees(btc *Backend, t *testing.T)

func TestMedianFeesTheHardWay added in v0.5.0 

func TestMedianFeesTheHardWay(btc *Backend, t *testing.T)

Types

type AddressDeriver added in v0.4.0 

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

AddressDeriver generates unique addresses from an extended public key.

func NewAddressDeriver added in v0.4.0 

func NewAddressDeriver(xpub string, keyIndexer asset.KeyIndexer, chainParams *chaincfg.Params) (*AddressDeriver, uint32, error)

NewAddressDeriver creates a new AddressDeriver for the provided extended public key, KeyIndexer, and network parameters. Note that if the source wallet has accounts (e.g. BIP44), the extended key should be for an account. Since AddressDeriver returns P2WPKH addresses, the extended public key should be for a P2WPKH derivation path (e.g. zpub for mainnet, and vpub for regnet and testnet). However, if a key for a different address encoding is provided that is otherwise valid for the specified network, the error message will suggest the equivalent extended key for P2WPKH addresses, but the operator must be certain they can redeem payments to P2WPKH addresses. This is done instead of returning different encodings depending on the extended key format to prevent accidental reuse of keys.

Refs: https://github.com/bitcoin/bips/blob/master/bip-0084.mediawiki#extended-key-version https://github.com/satoshilabs/slips/blob/master/slip-0132.md

See TestAddressDeriver to double check your own keys and the first addresses.

func (*AddressDeriver) NextAddress added in v0.4.0 

func (ap *AddressDeriver) NextAddress() (string, error)

NextAddress retrieves the p2wpkh address for the next pubkey. While this should always return a valid address, an empty string may be returned in the event of an unexpected internal error.

type Backend 

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

Backend is a dex backend for Bitcoin or a Bitcoin clone. It has methods for fetching UTXO information and subscribing to block updates. It maintains a cache of block data for quick lookups. Backend implements asset.Backend, so provides exported methods for DEX-related blockchain info.

func NewBTCClone 

func NewBTCClone(cloneCfg *BackendCloneConfig) (*Backend, error)

NewBTCClone creates a BTC backend for a set of network parameters and default network ports. A BTC clone can use this method, possibly in conjunction with ReadCloneParams, to create a Backend for other assets with minimal coding. See ReadCloneParams and CompatibilityCheck for more info.

func (*Backend) BlockChannel 

func (btc *Backend) BlockChannel(size int) <-chan *asset.BlockUpdate

BlockChannel creates and returns a new channel on which to receive block updates. If the returned channel is ever blocking, there will be no error logged from the btc package. Part of the asset.Backend interface.

func (*Backend) BondCoin added in v0.6.0 

func (btc *Backend) BondCoin(ctx context.Context, ver uint16, coinID []byte) (amt, lockTime, confs int64, acct account.AccountID, err error)

BondCoin locates a bond transaction output, validates the entire transaction, and returns the amount, encoded lockTime and account ID, and the confirmations of the transaction. It is a CoinNotFoundError if the transaction output is spent.

func (*Backend) BondVer added in v0.6.0 

func (dcr *Backend) BondVer() uint16

BondVer returns the latest supported bond version.

func (*Backend) CheckSwapAddress added in v0.6.0 

func (btc *Backend) CheckSwapAddress(addr string) bool

CheckSwapAddress checks that the given address is parseable, and suitable as a redeem address in a swap contract script.

func (*Backend) Connect added in v0.2.0 

func (btc *Backend) Connect(ctx context.Context) (*sync.WaitGroup, error)

Connect connects to the node RPC server. A dex.Connector.

func (*Backend) Contract 

func (btc *Backend) Contract(coinID []byte, redeemScript []byte) (*asset.Contract, error)

Contract is part of the asset.Backend interface. An asset.Contract is an output that has been validated as a swap contract for the passed redeem script. A spendable output is one that can be spent in the next block. Every output from a non-coinbase transaction is spendable immediately. Coinbase outputs are only spendable after CoinbaseMaturity confirmations. Pubkey scripts can be P2PKH or P2SH. Multi-sig P2SH redeem scripts are supported.

func (*Backend) FeeCoin added in v0.4.0 

func (btc *Backend) FeeCoin(coinID []byte) (addr string, val uint64, confs int64, err error)

FeeCoin gets the recipient address, value, and confirmations of a transaction output encoded by the given coinID. A non-nil error is returned if the output's pubkey script is not a P2WPKH requiring a single ECDSA-secp256k1 signature.

func (*Backend) FeeRate 

func (btc *Backend) FeeRate(ctx context.Context) (uint64, error)

FeeRate returns the current optimal fee rate in sat / byte.

func (*Backend) FundingCoin 

func (btc *Backend) FundingCoin(_ context.Context, coinID []byte, redeemScript []byte) (asset.FundingCoin, error)

FundingCoin is an unspent output.

func (*Backend) Info added in v0.5.0 

func (*Backend) Info() *asset.BackendInfo

Info provides some general information about the backend.

func (*Backend) InitTxSize 

func (btc *Backend) InitTxSize() uint32

InitTxSize is an asset.Backend method that must produce the max size of a standardized atomic swap initialization transaction.

func (*Backend) InitTxSizeBase 

func (btc *Backend) InitTxSizeBase() uint32

InitTxSizeBase is InitTxSize not including an input.

func (*Backend) Net added in v0.2.0 

func (btc *Backend) Net() *chaincfg.Params

Net returns the *chaincfg.Params. This is not part of the asset.Backend interface, and is exported as a convenience for embedding types.

func (*Backend) ParseBondTx added in v0.6.0 

func (btc *Backend) ParseBondTx(ver uint16, rawTx []byte) (bondCoinID []byte, amt int64, bondAddr string,
	bondPubKeyHash []byte, lockTime int64, acct account.AccountID, err error)

ParseBondTx makes the package-level ParseBondTx pure function accessible via a Backend instance. This performs basic validation of a serialized time-locked fidelity bond transaction given the bond's P2SH redeem script.

func (*Backend) Redemption 

func (btc *Backend) Redemption(redemptionID, contractID, _ []byte) (asset.Coin, error)

Redemption is an input that redeems a swap contract.

func (*Backend) Synced 

func (btc *Backend) Synced() (bool, error)

Synced is true if the blockchain is ready for action.

func (*Backend) TxData added in v0.2.0 

func (btc *Backend) TxData(coinID []byte) ([]byte, error)

TxData is the raw transaction bytes. SPV clients rebroadcast the transaction bytes to get around not having a mempool to check.

func (*Backend) ValidateCoinID 

func (btc *Backend) ValidateCoinID(coinID []byte) (string, error)

ValidateCoinID attempts to decode the coinID.

func (*Backend) ValidateContract 

func (btc *Backend) ValidateContract(contract []byte) error

ValidateContract ensures that the swap contract is constructed properly, and contains valid sender and receiver addresses.

func (*Backend) ValidateFeeRate added in v0.5.0 

func (*Backend) ValidateFeeRate(contract *asset.Contract, reqFeeRate uint64) bool

ValidateFeeRate checks that the transaction fees used to initiate the contract are sufficient.

func (*Backend) ValidateSecret 

func (btc *Backend) ValidateSecret(secret, contract []byte) bool

ValidateSecret checks that the secret satisfies the contract.

func (*Backend) VerifyUnspentCoin 

func (btc *Backend) VerifyUnspentCoin(_ context.Context, coinID []byte) error

VerifyUnspentCoin attempts to verify a coin ID by decoding the coin ID and retrieving the corresponding UTXO. If the coin is not found or no longer unspent, an asset.CoinNotFoundError is returned.

type BackendCloneConfig added in v0.2.0 

type BackendCloneConfig struct {
	Name           string
	Segwit         bool
	ConfigPath     string
	AddressDecoder dexbtc.AddressDecoder
	Logger         dex.Logger
	Net            dex.Network
	ChainParams    *chaincfg.Params
	Ports          dexbtc.NetPorts
	// ManualFeeScan specifies that median block fees should be calculated by
	// scanning transactions since the getblockstats rpc is not available.
	// Median block fees are used to estimate fee rates when the cache is not
	// primed.
	ManualMedianFee bool
	// NoCompetitionFeeRate specifies a fee rate to use if estimatesmartfee
	// or estimatefee aren't ready and the median fee is finding relatively
	// empty blocks.
	NoCompetitionFeeRate uint64
	// DumbFeeEstimates is for asset's whose RPC is estimatefee instead of
	// estimatesmartfee.
	DumbFeeEstimates bool
	// Argsless fee estimates are for assets who don't take an argument for
	// number of blocks to estimatefee.
	ArglessFeeEstimates bool
	// FeeConfs specifies the target number of confirmations to use for
	// estimate(smart)fee. If not set, default value is 1,
	FeeConfs int64
	// MaxFeeBlocks is the maximum number of blocks that can be evaluated for
	// median fee calculations. If > 100 txs are not seen in the last
	// MaxFeeBlocks, then the NoCompetitionRate will be returned as the median
	// fee.
	MaxFeeBlocks int
	// BooleanGetBlockRPC will pass true instead of 2 as the getblock argument.
	BooleanGetBlockRPC bool
	// BlockDeserializer can be used in place of (*wire.MsgBlock).Deserialize.
	BlockDeserializer func(blk []byte) (*wire.MsgBlock, error)
	// TxDeserializer is an optional function used to deserialize a transaction.
	// TxDeserializer is only used if ManualMedianFee is true.
	TxDeserializer func([]byte) (*wire.MsgTx, error)
	// TxHasher is a function that generates a tx hash from a MsgTx.
	TxHasher func(*wire.MsgTx) *chainhash.Hash
	// BlockFeeTransactions is a function to fetch a set of FeeTx and a previous
	// block hash for a specific block.
	BlockFeeTransactions BlockFeeTransactions
	// NumericGetRawRPC uses a numeric boolean indicator for the
	// getrawtransaction RPC.
	NumericGetRawRPC bool
	// ShieldedIO is a function to read a transaction and calculate the shielded
	// input and output amounts. This is a temporary measure until zcashd
	// encodes valueBalanceOrchard in their getrawtransaction RPC results.
	ShieldedIO     func(tx *VerboseTxExtended) (in, out uint64, err error)
	InitTxSize     uint32
	InitTxSizeBase uint32
}

BackendCloneConfig captures the arguments necessary to configure a BTC clone backend.

type BlockFeeTransactions added in v0.5.0 

type BlockFeeTransactions func(rc *RPCClient, blockHash *chainhash.Hash) (feeTxs []FeeTx, prevBlock chainhash.Hash, err error)

BlockFeeTransactions is a function that fetches a set of FeeTx, used to calculate median-fees manually.

type Driver 

type Driver struct{}

Driver implements asset.Driver.

func (*Driver) DecodeCoinID 

func (d *Driver) DecodeCoinID(coinID []byte) (string, error)

DecodeCoinID creates a human-readable representation of a coin ID for Bitcoin.

func (*Driver) NewAddresser added in v0.4.0 

func (d *Driver) NewAddresser(xPub string, keyIndexer asset.KeyIndexer, network dex.Network) (asset.Addresser, uint32, error)

NewAddresser creates an asset.Addresser for deriving addresses for the given extended public key. The KeyIndexer will be used for discovering the current child index, and storing the index as new addresses are generated with the NextAddress method of the Addresser.

func (*Driver) Setup 

func (d *Driver) Setup(configPath string, logger dex.Logger, network dex.Network) (asset.Backend, error)

Setup creates the BTC backend. Start the backend with its Run method.

func (*Driver) UnitInfo added in v0.4.0 

func (d *Driver) UnitInfo() dex.UnitInfo

UnitInfo returns the dex.UnitInfo for the asset.

func (*Driver) Version added in v0.2.0 

func (d *Driver) Version() uint32

Version returns the Backend implementation's version number.

type FeeTx added in v0.5.0 

type FeeTx interface {
	PrevOuts() []wire.OutPoint
	FeeRate(map[chainhash.Hash]map[int]int64) (uint64, error)
}

FeeTx is a representation of a transaction that 1) has zero or more previous outpoints to fetch, and 2) given the requested outpoints, can report its tx fee rate, in Sats/byte.

type GetBlockVerboseResult added in v0.5.0 

type GetBlockVerboseResult struct {
	Hash          string   `json:"hash"`
	Confirmations int64    `json:"confirmations"`
	Height        int64    `json:"height"`
	Tx            []string `json:"tx,omitempty"`
	PreviousHash  string   `json:"previousblockhash"`
}

GetBlockVerboseResult is a subset of *btcjson.GetBlockVerboseResult.

type GetBlockchainInfoResult added in v0.4.0 

type GetBlockchainInfoResult struct {
	Blocks               int64  `json:"blocks"`
	Headers              int64  `json:"headers"`
	BestBlockHash        string `json:"bestblockhash"`
	InitialBlockDownload bool   `json:"initialblockdownload"`
}

GetBlockchainInfoResult models the data returned from the getblockchaininfo command.

type Input 

type Input struct {
	TXIO
	// contains filtered or unexported fields
}

Input is a transaction input.

func (*Input) Confirmations 

func (input *Input) Confirmations(context.Context) (int64, error)

Confirmations returns the number of confirmations on this input's transaction.

func (*Input) ID 

func (input *Input) ID() []byte

ID returns the coin ID.

func (*Input) String 

func (input *Input) String() string

String creates a human-readable representation of a Bitcoin transaction input in the format "{txid = [transaction hash], vin = [input index]}".

func (*Input) Value 

func (input *Input) Value() uint64

Value is the value of the previous output spent by the input.

type JoinSplit added in v0.5.0 

type JoinSplit struct {
	// Old = input
	Old uint64 `json:"vpub_oldZat"`
	// New = output
	New uint64 `json:"vpub_newZat"`
}

JoinSplit represents a Zcash JoinSplit. https://zips.z.cash/protocol/canopy.pdf section 4.11

type Output 

type Output struct {
	TXIO
	// contains filtered or unexported fields
}

Output represents a transaction output.

func (*Output) Addresses 

func (output *Output) Addresses() []string

func (*Output) Auth 

func (output *Output) Auth(pubkeys, sigs [][]byte, msg []byte) error

Auth verifies that the output pays to the supplied public key(s). This is an asset.Backend method.

func (*Output) Confirmations 

func (output *Output) Confirmations(context.Context) (int64, error)

Confirmations returns the number of confirmations on this output's transaction.

func (*Output) ID 

func (output *Output) ID() []byte

ID returns the coin ID.

func (*Output) SpendSize 

func (output *Output) SpendSize() uint32

SpendSize returns the maximum size of the serialized TxIn that spends this output, in bytes. This is a method of the asset.Output interface.

func (*Output) String 

func (output *Output) String() string

String creates a human-readable representation of a Bitcoin transaction output in the format "{txid = [transaction hash], vout = [output index]}".

func (*Output) Value 

func (output *Output) Value() uint64

Value is the output value, in satoshis.

type RPCClient added in v0.4.0 

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

RPCClient is a bitcoind wallet RPC client that uses rpcclient.Client's RawRequest for wallet-related calls.

func (*RPCClient) Call added in v0.4.3 

func (rc *RPCClient) Call(method string, args []interface{}, thing interface{}) error

Call is used to marshal parameters and send requests to the RPC server via (*rpcclient.Client).RawRequest. If `thing` is non-nil, the result will be marshaled into `thing`.

func (*RPCClient) EstimateFee added in v0.5.0 

func (rc *RPCClient) EstimateFee(confTarget int64) (uint64, error)

EstimateFee requests the server to estimate a fee level.

func (*RPCClient) EstimateSmartFee added in v0.4.0 

func (rc *RPCClient) EstimateSmartFee(confTarget int64, mode *btcjson.EstimateSmartFeeMode) (uint64, error)

EstimateSmartFee requests the server to estimate a fee level.

func (*RPCClient) GetBestBlockHash added in v0.4.0 

func (rc *RPCClient) GetBestBlockHash() (*chainhash.Hash, error)

GetBestBlockHash returns the hash of the best block in the longest block chain.

func (*RPCClient) GetBlockChainInfo added in v0.4.0 

func (rc *RPCClient) GetBlockChainInfo() (*GetBlockchainInfoResult, error)

GetBlockChainInfo returns information related to the processing state of various chain-specific details.

func (*RPCClient) GetBlockVerbose added in v0.4.0 

func (rc *RPCClient) GetBlockVerbose(blockHash *chainhash.Hash) (*GetBlockVerboseResult, error)

GetBlockVerbose fetches verbose block data for the block with the given hash.

func (*RPCClient) GetMsgBlock added in v0.5.0 

func (rc *RPCClient) GetMsgBlock(blockHash *chainhash.Hash) (*wire.MsgBlock, error)

func (*RPCClient) GetRawBlock added in v0.5.0 

func (rc *RPCClient) GetRawBlock(blockHash *chainhash.Hash) ([]byte, error)

func (*RPCClient) GetRawTransaction added in v0.4.0 

func (rc *RPCClient) GetRawTransaction(txHash *chainhash.Hash) ([]byte, error)

GetRawTransaction retrieves tx's information.

func (*RPCClient) GetRawTransactionVerbose added in v0.4.0 

func (rc *RPCClient) GetRawTransactionVerbose(txHash *chainhash.Hash) (*VerboseTxExtended, error)

GetRawTransactionVerbose retrieves the verbose tx information.

func (*RPCClient) GetTxOut added in v0.4.0 

func (rc *RPCClient) GetTxOut(txHash *chainhash.Hash, index uint32, mempool bool) (*btcjson.GetTxOutResult, error)

GetTxOut returns the transaction output info if it's unspent and nil, otherwise.

func (*RPCClient) RawRequest added in v0.4.0 

func (rc *RPCClient) RawRequest(method string, params []json.RawMessage) (json.RawMessage, error)

RawRequest is a wrapper func for callers that are not context-enabled.

type RawRequester added in v0.4.0 

type RawRequester interface {
	RawRequest(context.Context, string, []json.RawMessage) (json.RawMessage, error)
	Shutdown()
	WaitForShutdown()
}

RawRequester is for sending context-aware RPC requests, and has methods for shutting down the underlying connection. The returned error should be of type dcrjson.RPCError if non-nil.

type TXIO 

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

TXIO is common information stored with an Input or Output.

func (*TXIO) FeeRate 

func (txio *TXIO) FeeRate() uint64

FeeRate returns the transaction fee rate, in satoshi/vbyte.

func (*TXIO) TxID 

func (txio *TXIO) TxID() string

TxID is a string identifier for the transaction, typically a hexadecimal representation of the byte-reversed transaction hash.

type Tx 

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

Tx is information about a transaction. It must satisfy the asset.DEXTx interface to be DEX-compatible.

type UTXO 

type UTXO struct {
	*Output
}

A UTXO is information regarding an unspent transaction output.

func (*UTXO) Confirmations 

func (utxo *UTXO) Confirmations(context.Context) (int64, error)

Confirmations returns the number of confirmations on this output's transaction. See also (*Output).Confirmations. This function differs from the Output method in that it is necessary to relocate the utxo after a reorg, it may error if the output is spent.

type VerboseTxExtended added in v0.5.0 

type VerboseTxExtended struct {
	Hex           string          `json:"hex"`
	Txid          string          `json:"txid"`
	Size          int32           `json:"size,omitempty"`
	Vsize         int32           `json:"vsize,omitempty"`
	Vin           []*btcjson.Vin  `json:"vin"`
	Vout          []*btcjson.Vout `json:"vout"`
	BlockHash     string          `json:"blockhash,omitempty"`
	Confirmations uint64          `json:"confirmations,omitempty"`

	VJoinSplit          []*JoinSplit `json:"vjoinsplit"`
	ValueBalanceSapling int64        `json:"valueBalanceZat"` // Sapling pool
	// ValueBalanceOrchard is disabled until zcashd encodes valueBalanceOrchard.
	ValueBalanceOrchard int64 `json:"valueBalanceOrchardZat"` // Orchard pool

}

VerboseTxExtended is a subset of *btcjson.TxRawResult, with the addition of some asset-specific fields.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.