wallet

package module
v8.0.12 Latest Latest
Warning

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

 Go to latest Published: Jun 27, 2022 License: ISC Imports: 50 Imported by: 0

README

wallet

Feature Overview

TODO: Flesh out this section

Documentation

GoDoc

Full go doc style documentation for the project can be viewed online without installing this package by using the GoDoc site here: https://godoc.org/github.com/Decred-Next/dcrnwallet/wallet/version3/v8

You can also view the documentation locally once the package is installed with the godoc tool by running godoc -http=":6060" and pointing your browser to http://localhost:6060/pkg/github.com/Decred-Next/dcrnwallet/wallet/version3/v8

Installation

$ go get github.com/Decred-Next/dcrnwallet/wallet/version3/v8

Package wallet is licensed under the copyfree ISC License.

Documentation

Overview

Package wallet provides ... TODO: Flesh out this section

Overview

Index

Constants

View Source 
const (
	// OutputSelectionAlgorithmDefault describes the default output selection
	// algorithm.  It is not optimized for any particular use case.
	OutputSelectionAlgorithmDefault = iota

	// OutputSelectionAlgorithmAll describes the output selection algorithm of
	// picking every possible available output.  This is useful for sweeping.
	OutputSelectionAlgorithmAll
)
View Source 
const DefaultAccountGapLimit = 10

DefaultAccountGapLimit is the default number of accounts that can be created in a row without using any of them

View Source 
const DefaultGapLimit = 20

DefaultGapLimit is the default unused address gap limit defined by BIP0044.

View Source 
const (
	// InsecurePubPassphrase is the default outer encryption passphrase used
	// for public data (everything but private keys).  Using a non-default
	// public passphrase can prevent an attacker without the public
	// passphrase from discovering all past and future wallet addresses if
	// they gain access to the wallet database.
	//
	// NOTE: at time of writing, public encryption only applies to public
	// data in the waddrmgr namespace.  Transactions are not yet encrypted.
	InsecurePubPassphrase = "public"
)

Variables

View Source 
var (
	// SimulationPassphrase is the password for a wallet created for simnet
	// with --createtemp.
	SimulationPassphrase = []byte("password")
)

Functions

func Create 

func Create(ctx context.Context, db DB, pubPass, privPass, seed []byte, params *chaincfg.Params) error

Create creates an new wallet, writing it to an empty database. If the passed seed is non-nil, it is used. Otherwise, a secure random seed of the recommended length is generated.

func CreateWatchOnly 

func CreateWatchOnly(ctx context.Context, db DB, extendedPubKey string, pubPass []byte, params *chaincfg.Params) error

CreateWatchOnly creates a watchonly wallet on the provided db.

func CurrentAgendas 

func CurrentAgendas(params *chaincfg.Params) (version uint32, agendas []chaincfg.ConsensusDeployment)

CurrentAgendas returns the current stake version for the active network and this version of the software, and all agendas defined by it.

func DisableLog 

func DisableLog()

DisableLog disables all library log output. Logging output is disabled by default until either UseLogger or SetLogWriter are called.

func UnstableAPI 

func UnstableAPI(w *Wallet) unstableAPI

UnstableAPI exposes additional unstable public APIs for a Wallet. These APIs may be changed or removed at any time. Currently this type exists to ease the transition (particularly for the legacy JSON-RPC server) from using exported manager packages to a unified wallet package that exposes all functionality by itself. New code should not be written using this API.

func UseLogger 

func UseLogger(logger slog.Logger)

UseLogger uses a specified Logger to output package logging info. This should be used in preference to SetLogWriter if the caller is also using slog.

func VerifyMessage 

func VerifyMessage(msg string, addr dcrutil.Address, sig []byte, params dcrutil.AddressParams) (bool, error)

VerifyMessage verifies that sig is a valid signature of msg and was created using the secp256k1 private key for addr.

Types

type AccountBalance 

type AccountBalance struct {
	Account      uint32
	TotalBalance dcrutil.Amount
}

AccountBalance associates a total (zero confirmation) balance with an account. Balances for other minimum confirmation counts require more expensive logic and it is not clear which minimums a client is interested in, so they are not included.

type AccountNotification 

type AccountNotification struct {
	AccountNumber    uint32
	AccountName      string
	ExternalKeyCount uint32
	InternalKeyCount uint32
	ImportedKeyCount uint32
}

AccountNotification contains properties regarding an account, such as its name and the number of derived and imported keys. When any of these properties change, the notification is fired.

type AccountNotificationsClient 

type AccountNotificationsClient struct {
	C chan *AccountNotification
	// contains filtered or unexported fields
}

AccountNotificationsClient receives AccountNotifications over the channel C.

func (*AccountNotificationsClient) Done 

func (c *AccountNotificationsClient) Done()

Done deregisters the client from the server and drains any remaining messages. It must be called exactly once when the client is finished receiving notifications.

type AccountResult 

type AccountResult struct {
	udb.AccountProperties
	TotalBalance dcrutil.Amount
}

AccountResult is a single account result for the AccountsResult type.

type AccountTotalReceivedResult 

type AccountTotalReceivedResult struct {
	AccountNumber    uint32
	AccountName      string
	TotalReceived    dcrutil.Amount
	LastConfirmation int32
}

AccountTotalReceivedResult is a single result for the Wallet.TotalReceivedForAccounts method.

type AccountsResult 

type AccountsResult struct {
	Accounts           []AccountResult
	CurrentBlockHash   *chainhash.Hash
	CurrentBlockHeight int32
}

AccountsResult is the resutl of the wallet's Accounts method. See that method for more details.

type AddressP2PKHv0 

type AddressP2PKHv0 interface {
	dcrutil.Address
	V0Scripter
	SecpPubKeyHasher
	SecpPubKeyHash160er
}

AddressP2PKHv0 is a union of interfaces implemented by version 0 P2PKH addresses.

type AgendaChoice 

type AgendaChoice struct {
	AgendaID string
	ChoiceID string
}

AgendaChoice describes a user's choice for a consensus deployment agenda.

type BIP44AccountXpubPather 

type BIP44AccountXpubPather interface {
	BIP44AccountXpubPath() (xpub *hdkeychain.ExtendedKey, branch, child uint32)
}

BIP44AccountXpubPather is any address which is derived from a BIP0044 extended pubkey.

type BIP44XpubP2PKHv0 

type BIP44XpubP2PKHv0 interface {
	AddressP2PKHv0
	SecpPubKeyer
	BIP44AccountXpubPather
}

BIP44XpubP2PKHv0 is a union of interfaces implemented by version 0 P2PKH addresses derived from a known BIP0044 account xpub.

type Block 

type Block struct {
	Header       *wire.BlockHeader // Nil if referring to mempool
	Transactions []TransactionSummary
}

Block contains the properties and all relevant transactions of an attached block.

type BlockIdentifier 

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

BlockIdentifier identifies a block by either a height in the main chain or a hash.

func NewBlockIdentifierFromHash 

func NewBlockIdentifierFromHash(hash *chainhash.Hash) *BlockIdentifier

NewBlockIdentifierFromHash constructs a BlockIdentifier for a block hash.

func NewBlockIdentifierFromHeight 

func NewBlockIdentifierFromHeight(height int32) *BlockIdentifier

NewBlockIdentifierFromHeight constructs a BlockIdentifier for a block height.

type BlockIdentity 

type BlockIdentity struct {
	Hash   chainhash.Hash
	Height int32
}

BlockIdentity identifies a block, or the lack of one (used to describe an unmined transaction).

func (*BlockIdentity) None 

func (b *BlockIdentity) None() bool

None returns whether there is no block described by the instance. When associated with a transaction, this indicates the transaction is unmined.

type BlockInfo 

type BlockInfo struct {
	Hash             chainhash.Hash
	Height           int32
	Confirmations    int32
	Header           []byte
	Timestamp        int64
	StakeInvalidated bool
}

BlockInfo records info pertaining to a block. It does not include any information about wallet transactions contained in the block.

type BlockNode 

type BlockNode struct {
	Header *wire.BlockHeader
	Hash   *chainhash.Hash
	Filter *gcs.Filter
	// contains filtered or unexported fields
}

BlockNode represents a block node for a SidechainForest. BlockNodes are not safe for concurrent access, and all exported fields must be treated as immutable.

func NewBlockNode 

func NewBlockNode(header *wire.BlockHeader, hash *chainhash.Hash, filter *gcs.Filter) *BlockNode

NewBlockNode creates a block node for usage with a SidechainForest.

type Caller 

type Caller interface {
	// Call performs the remote procedure call defined by method and
	// waits for a response or a broken client connection.
	// Args provides positional parameters for the call.
	// Res must be a pointer to a struct, slice, or map type to unmarshal
	// a result (if any), or nil if no result is needed.
	Call(ctx context.Context, method string, res interface{}, args ...interface{}) error
}

Caller provides a client interface to perform remote procedure calls. Serialization and calling conventions are implementation-specific.

type Config 

type Config struct {
	DB DB

	PubPassphrase []byte

	VotingEnabled bool
	AddressReuse  bool
	VotingAddress dcrutil.Address
	PoolAddress   dcrutil.Address
	PoolFees      float64
	TicketFee     float64

	GapLimit                int
	AccountGapLimit         int
	DisableCoinTypeUpgrades bool

	StakePoolColdExtKey string
	AllowHighFees       bool
	RelayFee            float64
	Params              *chaincfg.Params
}

Config represents the configuration options needed to initialize a wallet.

type ConfirmationNotification 

type ConfirmationNotification struct {
	TxHash        *chainhash.Hash
	Confirmations int32
	BlockHash     *chainhash.Hash // nil when unmined
	BlockHeight   int32           // -1 when unmined
}

ConfirmationNotification describes the number of confirmations of a single transaction, or -1 if the transaction is unknown or removed from the wallet. If the transaction is mined (Confirmations >= 1), the block hash and height is included. Otherwise the block hash is nil and the block height is set to -1.

type ConfirmationNotificationsClient 

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

ConfirmationNotificationsClient provides confirmation notifications of watched transactions until the caller's context signals done. Callers register for notifications using Watch and receive notifications by calling Recv.

func (*ConfirmationNotificationsClient) Recv 

func (c *ConfirmationNotificationsClient) Recv() ([]ConfirmationNotification, error)

Recv waits for the next notification. Returns context.Canceled when the context is canceled.

func (*ConfirmationNotificationsClient) Watch 

func (c *ConfirmationNotificationsClient) Watch(txHashes []*chainhash.Hash, stopAfter int32)

Watch adds additional transactions to watch and create confirmation results for. Results are immediately created with the current number of confirmations and are watched until stopAfter confirmations is met or the transaction is unknown or removed from the wallet.

type CreatedTx 

type CreatedTx struct {
	MsgTx       *wire.MsgTx
	ChangeAddr  dcrutil.Address
	ChangeIndex int // negative if no change
	Fee         dcrutil.Amount
}

CreatedTx holds the state of a newly-created transaction and the change output (if one was added).

type CreditCategory 

type CreditCategory byte

CreditCategory describes the type of wallet transaction output. The category of "sent transactions" (debits) is always "send", and is not expressed by this type.

TODO: This is a requirement of the RPC server and should be moved. 

const (
	CreditReceive CreditCategory = iota
	CreditGenerate
	CreditImmature
)

These constants define the possible credit categories.

func RecvCategory 

func RecvCategory(details *udb.TxDetails, syncHeight int32, chainParams *chaincfg.Params) CreditCategory

RecvCategory returns the category of received credit outputs from a transaction record. The passed block chain height is used to distinguish immature from mature coinbase outputs.

TODO: This is intended for use by the RPC server and should be moved out of this package at a later time.

func (CreditCategory) String 

func (c CreditCategory) String() string

String returns the category as a string. This string may be used as the JSON string for categories as part of listtransactions and gettransaction RPC responses.

type DB 

type DB interface {
	io.Closer
	// contains filtered or unexported methods
}

DB represents an ACID database for a wallet.

func CreateDB 

func CreateDB(driver string, args ...interface{}) (DB, error)

CreateDB creates a new database with some specific driver implementation. Args specify the arguments to open the database and may differ based on driver.

func OpenDB 

func OpenDB(driver string, args ...interface{}) (DB, error)

OpenDB opens a database with some specific driver implementation. Args specify the arguments to open the database and may differ based on driver.

type DialFunc 

type DialFunc func(ctx context.Context, network, addr string) (net.Conn, error)

DialFunc provides a method to dial a network connection. If the dialed network connection is secured by TLS, TLS configuration is provided by the method, not the caller.

type GetTicketsResult 

type GetTicketsResult struct {
	Tickets []*TicketSummary
}

GetTicketsResult response struct for gettickets rpc request

type GetTransactionsResult 

type GetTransactionsResult struct {
	MinedTransactions   []Block
	UnminedTransactions []TransactionSummary
}

GetTransactionsResult is the result of the wallet's GetTransactions method. See GetTransactions for more details.

type MainTipChangedNotification 

type MainTipChangedNotification struct {
	AttachedBlocks []*chainhash.Hash
	DetachedBlocks []*chainhash.Hash
	NewHeight      int32
}

MainTipChangedNotification describes processed changes to the main chain tip block. Attached and detached blocks are sorted by increasing heights.

This is intended to be a lightweight alternative to TransactionNotifications when only info regarding the main chain tip block changing is needed.

type MainTipChangedNotificationsClient 

type MainTipChangedNotificationsClient struct {
	C chan *MainTipChangedNotification
	// contains filtered or unexported fields
}

MainTipChangedNotificationsClient receives MainTipChangedNotifications over the channel C.

func (*MainTipChangedNotificationsClient) Done 

func (c *MainTipChangedNotificationsClient) Done()

Done deregisters the client from the server and drains any remaining messages. It must be called exactly once when the client is finished receiving notifications.

type MissingCFilterProgress 

type MissingCFilterProgress struct {
	Err              error
	BlockHeightStart int32
	BlockHeightEnd   int32
}

MissingCFilterProgress records the first and last height of the progress that was received and any errors that were received during the fetching.

type NetworkBackend 

type NetworkBackend interface {
	Peer
	LoadTxFilter(ctx context.Context, reload bool, addrs []dcrutil.Address, outpoints []wire.OutPoint) error
	Rescan(ctx context.Context, blocks []chainhash.Hash, save func(block *chainhash.Hash, txs []*wire.MsgTx) error) error

	// This is impossible to determine over the wire protocol, and will always
	// error.  Use Wallet.NextStakeDifficulty to calculate the next ticket price
	// when the DCP0001 deployment is known to be active.
	StakeDifficulty(ctx context.Context) (dcrutil.Amount, error)
}

NetworkBackend provides wallets with Decred network functionality. Some wallet operations require the wallet to be associated with a network backend to complete.

NetworkBackend expands on the Peer interface to provide additional functionality for rescanning and filtering.

type NextAddressCallOption 

type NextAddressCallOption func(*nextAddressCallOptions)

NextAddressCallOption defines a call option for the NextAddress family of wallet methods.

func WithGapPolicyError 

func WithGapPolicyError() NextAddressCallOption

WithGapPolicyError configures the NextAddress family of methods to error whenever the gap limit would be exceeded. When this default policy is used, callers should check errors against the GapLimit error code and let users specify whether to ignore the gap limit or wrap around to a previously returned address.

func WithGapPolicyIgnore 

func WithGapPolicyIgnore() NextAddressCallOption

WithGapPolicyIgnore configures the NextAddress family of methods to ignore the gap limit entirely when generating addresses. Exceeding the gap limit may result in unsynced address child indexes when seed restoring the wallet, unless the restoring gap limit is increased, as well as breaking automatic address synchronization of multiple running wallets.

This is a good policy to use when addresses must never be reused, but be aware of the issues noted above.

func WithGapPolicyWrap 

func WithGapPolicyWrap() NextAddressCallOption

WithGapPolicyWrap configures the NextAddress family of methods to wrap around to a previously returned address instead of erroring or ignoring the gap limit and returning a new unused address.

This is a good policy to use for most individual users' wallets where funds are segmented by accounts and not the addresses that control each output.

type NotificationServer 

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

NotificationServer is a server that interested clients may hook into to receive notifications of changes in a wallet. A client is created for each registered notification. Clients are guaranteed to receive messages in the order wallet created them, but there is no guaranteed synchronization between different clients.

func (*NotificationServer) AccountNotifications 

func (s *NotificationServer) AccountNotifications() AccountNotificationsClient

AccountNotifications returns a client for receiving AccountNotifications over a channel. The channel is unbuffered. When finished, the client's Done method should be called to disassociate the client from the server.

func (*NotificationServer) ConfirmationNotifications 

func (s *NotificationServer) ConfirmationNotifications(ctx context.Context) *ConfirmationNotificationsClient

ConfirmationNotifications registers a client for confirmation notifications from the notification server.

func (*NotificationServer) MainTipChangedNotifications 

func (s *NotificationServer) MainTipChangedNotifications() MainTipChangedNotificationsClient

MainTipChangedNotifications returns a client for receiving MainTipChangedNotification over a channel. The channel is unbuffered. When finished, the client's Done method should be called to disassociate the client from the server.

func (*NotificationServer) TransactionNotifications 

func (s *NotificationServer) TransactionNotifications() TransactionNotificationsClient

TransactionNotifications returns a client for receiving TransactionNotifiations notifications over a channel. The channel is unbuffered.

When finished, the Done method should be called on the client to disassociate it from the server.

type OutputInfo 

type OutputInfo struct {
	Received     time.Time
	Amount       dcrutil.Amount
	FromCoinbase bool
}

OutputInfo describes additional info about an output which can be queried using an outpoint.

type OutputKind 

type OutputKind byte

OutputKind describes a kind of transaction output. This is used to differentiate between coinbase, stakebase, and normal outputs. 

const (
	OutputKindNormal OutputKind = iota
	OutputKindCoinbase
	OutputKindStakebase // not returned by all APIs yet
)

Defined OutputKind constants

type OutputRedeemer 

type OutputRedeemer struct {
	TxHash     chainhash.Hash
	InputIndex uint32
}

OutputRedeemer identifies the transaction input which redeems an output.

type OutputSelectionAlgorithm 

type OutputSelectionAlgorithm uint

OutputSelectionAlgorithm specifies the algorithm to use when selecting outputs to construct a transaction.

type OutputSelectionPolicy 

type OutputSelectionPolicy struct {
	Account               uint32
	RequiredConfirmations int32
}

OutputSelectionPolicy describes the rules for selecting an output from the wallet.

type P2SHMultiSigOutput 

type P2SHMultiSigOutput struct {
	// TODO: Add a TransactionOutput member to this struct and remove these
	// fields which are duplicated by it.  This improves consistency.  Only
	// not done now because wtxmgr APIs don't support an efficient way of
	// fetching other Transactionoutput data together with the rest of the
	// multisig info.
	OutPoint        wire.OutPoint
	OutputAmount    dcrutil.Amount
	ContainingBlock BlockIdentity

	P2SHAddress  *dcrutil.AddressScriptHash
	RedeemScript []byte
	M, N         uint8           // M of N signatures required to redeem
	Redeemer     *OutputRedeemer // nil unless spent
}

P2SHMultiSigOutput describes a transaction output with a pay-to-script-hash output script and an imported redemption script. Along with common details of the output, this structure also includes the P2SH address the script was created from and the number of signatures required to redeem it.

TODO: Could be useful to return how many of the required signatures can be created by this wallet.

type Peer 

type Peer interface {
	Blocks(ctx context.Context, blockHashes []*chainhash.Hash) ([]*wire.MsgBlock, error)
	CFilters(ctx context.Context, blockHashes []*chainhash.Hash) ([]*gcs.Filter, error)
	Headers(ctx context.Context, blockLocators []*chainhash.Hash, hashStop *chainhash.Hash) ([]*wire.BlockHeader, error)
	PublishTransactions(ctx context.Context, txs ...*wire.MsgTx) error
}

Peer provides wallets with a subset of Decred network functionality available to a single peer.

type PurchaseTicketsRequest 

type PurchaseTicketsRequest struct {
	Count         int
	SourceAccount uint32
	VotingAddress dcrutil.Address
	MinConf       int32
	Expiry        int32
	VotingAccount uint32 // Used when VotingAddress == nil, or CSPPServer != ""

	// Mixed split buying through CoinShuffle++
	CSPPServer         string
	DialCSPPServer     DialFunc
	MixedAccount       uint32
	MixedAccountBranch uint32
	MixedSplitAccount  uint32
	ChangeAccount      uint32

	// VSP ticket buying; not currently usable with CoinShuffle++.
	VSPAddress dcrutil.Address
	VSPFees    float64
	// contains filtered or unexported fields
}

PurchaseTicketsRequest describes the parameters for purchasing tickets.

type RescanFilter 

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

RescanFilter implements a precise filter intended to hold all watched wallet data in memory such as addresses and unspent outputs. The zero value is not valid, and filters must be created using NewRescanFilter. RescanFilter is not safe for concurrent access.

func NewRescanFilter 

func NewRescanFilter(addresses []dcrutil.Address, unspentOutPoints []*wire.OutPoint) *RescanFilter

NewRescanFilter creates and initializes a RescanFilter containing each passed address and outpoint.

func (*RescanFilter) AddAddress 

func (f *RescanFilter) AddAddress(a dcrutil.Address)

AddAddress adds an address to the filter if it does not already exist.

func (*RescanFilter) AddUnspentOutPoint 

func (f *RescanFilter) AddUnspentOutPoint(op *wire.OutPoint)

AddUnspentOutPoint adds an outpoint to the filter if it does not already exist.

func (*RescanFilter) ExistsAddress 

func (f *RescanFilter) ExistsAddress(a dcrutil.Address) (ok bool)

ExistsAddress returns whether an address is contained in the filter.

func (*RescanFilter) ExistsUnspentOutPoint 

func (f *RescanFilter) ExistsUnspentOutPoint(op *wire.OutPoint) bool

ExistsUnspentOutPoint returns whether an outpoint is contained in the filter.

func (*RescanFilter) RemoveAddress 

func (f *RescanFilter) RemoveAddress(a dcrutil.Address)

RemoveAddress removes an address from the filter if it exists.

func (*RescanFilter) RemoveUnspentOutPoint 

func (f *RescanFilter) RemoveUnspentOutPoint(op *wire.OutPoint)

RemoveUnspentOutPoint removes an outpoint from the filter if it exists.

type RescanProgress 

type RescanProgress struct {
	Err            error
	ScannedThrough int32
}

RescanProgress records the height the rescan has completed through and any errors during processing of the rescan.

type SecpPubKeyHash160er 

type SecpPubKeyHash160er interface {
	SecpPubKeyHash160() *[20]byte
}

SecpPubKeyHash160er is any address created from the HASH160 of a pubkey.

type SecpPubKeyHasher 

type SecpPubKeyHasher interface {
	SecpPubKeyHash(version uint16) ([]byte, error)
}

SecpPubKeyHasher is any address used to create scripts paying to the hash of a secp256k1 pubkey, requiring the pubkey and a signature to redeem.

type SecpPubKeyer 

type SecpPubKeyer interface {
	SecpPubKey() []byte
}

SecpPubKeyer is any type (usually addresses) where a secp256k1 public key is known.

type SidechainForest 

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

SidechainForest provides in-memory management of sidechain and orphan blocks. It implements a forest of disjoint rooted trees, each tree containing sidechains stemming from a different fork point in the main chain, or orphans.

SidechainForest is not safe for concurrent access.

func (*SidechainForest) AddBlockNode 

func (f *SidechainForest) AddBlockNode(n *BlockNode) bool

AddBlockNode adds a sidechain block node to the forest. The node may either begin a new sidechain, extend an existing sidechain, or start or extend a tree of orphan blocks. Adding the parent node of a previously-saved orphan block will restructure the forest by re-rooting the previous orphan tree onto the tree containing the added node. Returns true iff the node if the node was not a duplicate.

func (*SidechainForest) Prune 

func (f *SidechainForest) Prune(mainChainHeight int32, params *chaincfg.Params)

Prune removes any sidechain trees which contain a root that is significantly behind the current main chain tip block.

func (*SidechainForest) PruneTree 

func (f *SidechainForest) PruneTree(root *chainhash.Hash)

PruneTree removes the tree beginning with root from the forest.

type SignatureError 

type SignatureError struct {
	InputIndex uint32
	Error      error
}

SignatureError records the underlying error when validating a transaction input signature.

type StakeDifficultyInfo 

type StakeDifficultyInfo struct {
	BlockHash       *chainhash.Hash
	BlockHeight     int64
	StakeDifficulty int64
}

StakeDifficultyInfo is a container for stake difficulty information updates.

type StakeInfoData 

type StakeInfoData struct {
	BlockHeight  int64
	TotalSubsidy dcrutil.Amount
	Sdiff        dcrutil.Amount

	OwnMempoolTix  uint32
	Unspent        uint32
	Voted          uint32
	Revoked        uint32
	UnspentExpired uint32

	PoolSize      uint32
	AllMempoolTix uint32
	Immature      uint32
	Live          uint32
	Missed        uint32
	Expired       uint32
}

StakeInfoData carries counts of ticket states and other various stake data.

type TicketStatus 

type TicketStatus int8

TicketStatus describes the current status a ticket can be observed to be. 

const (
	// TicketStatusUnknown any ticket that its status was unable to be determined.
	TicketStatusUnknown TicketStatus = iota
	// TicketStatusUnmined any not yet mined ticket.
	TicketStatusUnmined
	// TicketStatusImmature any so to be live ticket.
	TicketStatusImmature
	// TicketStatusLive any currently live ticket.
	TicketStatusLive
	// TicketStatusVoted any ticket that was seen to have voted.
	TicketStatusVoted
	// TicketStatusRevoked any ticket that has been previously revoked.
	TicketStatusRevoked
	// TicketStatusMissed any ticket that has yet to be revoked, and was missed.
	TicketStatusMissed
	// TicketStatusExpired any ticket that has yet to be revoked, and was expired.
	TicketStatusExpired
)

type TicketSummary 

type TicketSummary struct {
	Ticket  *TransactionSummary
	Spender *TransactionSummary
	Status  TicketStatus
}

TicketSummary contains the properties to describe a ticket's current status

type TransactionNotifications 

type TransactionNotifications struct {
	AttachedBlocks           []Block
	DetachedBlocks           []*chainhash.Hash
	UnminedTransactions      []TransactionSummary
	UnminedTransactionHashes []*chainhash.Hash
	NewBalances              []AccountBalance
}

TransactionNotifications is a notification of changes to the wallet's transaction set and the current chain tip that wallet is considered to be synced with. All transactions added to the blockchain are organized by the block they were mined in.

During a chain switch, all removed block hashes are included. Detached blocks are sorted in the reverse order they were mined. Attached blocks are sorted in the order mined.

All newly added unmined transactions are included. Removed unmined transactions are not explicitly included. Instead, the hashes of all transactions still unmined are included.

If any transactions were involved, each affected account's new total balance is included.

TODO: Because this includes stuff about blocks and can be fired without any changes to transactions, it needs a better name.

type TransactionNotificationsClient 

type TransactionNotificationsClient struct {
	C <-chan *TransactionNotifications
	// contains filtered or unexported fields
}

TransactionNotificationsClient receives TransactionNotifications from the NotificationServer over the channel C.

func (*TransactionNotificationsClient) Done 

func (c *TransactionNotificationsClient) Done()

Done deregisters the client from the server and drains any remaining messages. It must be called exactly once when the client is finished receiving notifications.

type TransactionOutput 

type TransactionOutput struct {
	OutPoint   wire.OutPoint
	Output     wire.TxOut
	OutputKind OutputKind
	// These should be added later when the DB can return them more
	// efficiently:
	//TxLockTime      uint32
	//TxExpiry        uint32
	ContainingBlock BlockIdentity
	ReceiveTime     time.Time
}

TransactionOutput describes an output that was or is at least partially controlled by the wallet. Depending on context, this could refer to an unspent output, or a spent one.

type TransactionSummary 

type TransactionSummary struct {
	Hash        *chainhash.Hash
	Transaction []byte
	MyInputs    []TransactionSummaryInput
	MyOutputs   []TransactionSummaryOutput
	Fee         dcrutil.Amount
	Timestamp   int64
	Type        TransactionType
}

TransactionSummary contains a transaction relevant to the wallet and marks which inputs and outputs were relevant.

type TransactionSummaryInput 

type TransactionSummaryInput struct {
	Index           uint32
	PreviousAccount uint32
	PreviousAmount  dcrutil.Amount
}

TransactionSummaryInput describes a transaction input that is relevant to the wallet. The Index field marks the transaction input index of the transaction (not included here). The PreviousAccount and PreviousAmount fields describe how much this input debits from a wallet account.

type TransactionSummaryOutput 

type TransactionSummaryOutput struct {
	Index        uint32
	Account      uint32
	Internal     bool
	Amount       dcrutil.Amount
	Address      dcrutil.Address
	OutputScript []byte
}

TransactionSummaryOutput describes wallet properties of a transaction output controlled by the wallet. The Index field marks the transaction output index of the transaction (not included here).

type TransactionType 

type TransactionType int8

TransactionType describes the which type of transaction is has been observed to be. For instance, if it has a ticket as an input and a stake base reward as an output, it is known to be a vote. 

const (
	// TransactionTypeRegular transaction type for all regular transactions.
	TransactionTypeRegular TransactionType = iota

	// TransactionTypeCoinbase is the transaction type for all coinbase transactions.
	TransactionTypeCoinbase

	// TransactionTypeTicketPurchase transaction type for all transactions that
	// consume regular transactions as inputs and have commitments for future votes
	// as outputs.
	TransactionTypeTicketPurchase

	// TransactionTypeVote transaction type for all transactions that consume a ticket
	// and also offer a stake base reward output.
	TransactionTypeVote

	// TransactionTypeRevocation transaction type for all transactions that consume a
	// ticket, but offer no stake base reward.
	TransactionTypeRevocation
)

func TxTransactionType 

func TxTransactionType(tx *wire.MsgTx) TransactionType

TxTransactionType returns the correct TransactionType given a wire transaction

type V0Scripter 

type V0Scripter interface {
	ScriptV0() []byte
}

V0Scripter is a type (usually addresses) which create or encode to version 0 output scripts. tags test11

type Wallet 

type Wallet struct {
	Manager  *udb.Manager
	TxStore  *udb.Store
	StakeMgr *udb.StakeStore

	DisallowFree  bool
	AllowHighFees bool

	NtfnServer *NotificationServer
	// contains filtered or unexported fields
}

Wallet is a structure containing all the components for a complete wallet. It contains the Armory-style key store addresses and keys),

func Open 

func Open(ctx context.Context, cfg *Config) (*Wallet, error)

Open loads an already-created wallet from the passed database and namespaces configuration options and sets it up it according to the rest of options.

func (*Wallet) AbandonTransaction 

func (w *Wallet) AbandonTransaction(ctx context.Context, hash *chainhash.Hash) error

AbandonTransaction removes a transaction, identified by its hash, from the wallet if present. All transaction spend chains deriving from the transaction's outputs are also removed. Does not error if the transaction doesn't already exist unmined, but will if the transaction is marked mined in a block on the main chain.

Purged transactions may have already been published to the network and may still appear in future blocks, and new transactions spending the same inputs as purged transactions may be rejected by full nodes due to being double spends. In turn, this can cause the purged transaction to be mined later and replace other transactions authored by the wallet.

func (*Wallet) AcceptMempoolTx 

func (w *Wallet) AcceptMempoolTx(ctx context.Context, tx *wire.MsgTx) error

AcceptMempoolTx adds a relevant unmined transaction to the wallet. If a network backend is associated with the wallet, it is updated with new addresses and unspent outpoints to watch.

func (*Wallet) AccountBranchAddressRange deprecated 

func (w *Wallet) AccountBranchAddressRange(account, branch, start, end uint32) ([]dcrutil.Address, error)

AccountBranchAddressRange returns all addresses in the range [start, end) belonging to the BIP0044 account and address branch.

Deprecated: Dump the xpub and perform this yourself. The addresses returned by this function do not implement all of the wallet's address interfaces.

func (*Wallet) AccountName 

func (w *Wallet) AccountName(ctx context.Context, accountNumber uint32) (string, error)

AccountName returns the name of an account.

func (*Wallet) AccountNumber 

func (w *Wallet) AccountNumber(ctx context.Context, accountName string) (uint32, error)

AccountNumber returns the account number for an account name.

func (*Wallet) AccountOfAddress 

func (w *Wallet) AccountOfAddress(ctx context.Context, a dcrutil.Address) (uint32, error)

AccountOfAddress finds the account that an address is associated with.

func (*Wallet) AccountProperties 

func (w *Wallet) AccountProperties(ctx context.Context, acct uint32) (*udb.AccountProperties, error)

AccountProperties returns the properties of an account, including address indexes and name. It first fetches the desynced information from the address manager, then updates the indexes based on the address pools.

func (*Wallet) Accounts 

func (w *Wallet) Accounts(ctx context.Context) (*AccountsResult, error)

Accounts returns the current names, numbers, and total balances of all accounts in the wallet. The current chain tip is included in the result for atomicity reasons.

TODO(jrick): Is the chain tip really needed, since only the total balances are included?

func (*Wallet) AddTicket 

func (w *Wallet) AddTicket(ctx context.Context, ticket *wire.MsgTx) error

AddTicket adds a ticket transaction to the stake manager. It is not added to the transaction manager because it is unknown where the transaction belongs on the blockchain. It will be used to create votes.

func (*Wallet) AddressInfo 

func (w *Wallet) AddressInfo(ctx context.Context, a dcrutil.Address) (udb.ManagedAddress, error)

AddressInfo returns detailed information regarding a wallet address.

func (*Wallet) AgendaChoices 

func (w *Wallet) AgendaChoices(ctx context.Context) (choices []AgendaChoice, voteBits uint16, err error)

AgendaChoices returns the choice IDs for every agenda of the supported stake version. Abstains are included.

func (*Wallet) BIP0044BranchNextIndexes 

func (w *Wallet) BIP0044BranchNextIndexes(ctx context.Context, account uint32) (extChild, intChild uint32, err error)

BIP0044BranchNextIndexes returns the next external and internal branch child indexes of an account.

func (*Wallet) BalanceToMaintain 

func (w *Wallet) BalanceToMaintain() dcrutil.Amount

BalanceToMaintain is used to get the current balancetomaintain for the wallet.

func (*Wallet) BlockHeader 

func (w *Wallet) BlockHeader(ctx context.Context, blockHash *chainhash.Hash) (*wire.BlockHeader, error)

BlockHeader returns the block header for a block by it's identifying hash, if it is recorded by the wallet.

func (*Wallet) BlockInMainChain 

func (w *Wallet) BlockInMainChain(ctx context.Context, hash *chainhash.Hash) (haveBlock, invalidated bool, err error)

BlockInMainChain returns whether hash is a block hash of any block in the wallet's main chain. If the block is in the main chain, invalidated reports whether a child block in the main chain stake invalidates the queried block.

func (*Wallet) BlockInfo 

func (w *Wallet) BlockInfo(ctx context.Context, blockID *BlockIdentifier) (*BlockInfo, error)

BlockInfo returns info regarding a block recorded by the wallet.

func (*Wallet) BlockLocators 

func (w *Wallet) BlockLocators(ctx context.Context, sidechain []*BlockNode) ([]*chainhash.Hash, error)

BlockLocators returns block locators, suitable for use in a getheaders wire message or dcrd JSON-RPC request, for the blocks in sidechain and saved in the wallet's main chain. For memory and lookup efficiency, many older hashes are skipped, with increasing gaps between included hashes.

When sidechain has zero length, locators for only main chain blocks starting from the tip are returned. Otherwise, locators are created starting with the best (last) block of sidechain and sidechain[0] must be a child of a main chain block (sidechain may not contain orphan blocks).

func (*Wallet) CFilter 

func (w *Wallet) CFilter(ctx context.Context, blockHash *chainhash.Hash) (*gcs.Filter, error)

CFilter returns the regular compact filter for a block.

func (*Wallet) CalculateAccountBalance 

func (w *Wallet) CalculateAccountBalance(ctx context.Context, account uint32, confirms int32) (udb.Balances, error)

CalculateAccountBalance sums the amounts of all unspent transaction outputs to the given account of a wallet and returns the balance.

func (*Wallet) CalculateAccountBalances 

func (w *Wallet) CalculateAccountBalances(ctx context.Context, confirms int32) (map[uint32]*udb.Balances, error)

CalculateAccountBalances calculates the values for the wtxmgr struct Balance, which includes the total balance, the spendable balance, and the balance which has yet to mature.

func (*Wallet) ChainParams 

func (w *Wallet) ChainParams() *chaincfg.Params

ChainParams returns the network parameters for the blockchain the wallet belongs to.

func (*Wallet) ChainSwitch 

func (w *Wallet) ChainSwitch(ctx context.Context, forest *SidechainForest, chain []*BlockNode, relevantTxs map[chainhash.Hash][]*wire.MsgTx) ([]*BlockNode, error)

ChainSwitch updates the wallet's main chain, either by extending the chain with new blocks, or switching to a better sidechain. A sidechain for removed blocks (if any) is returned. If relevantTxs is non-nil, the block marker for the latest block with processed transactions is updated for the new tip block.

func (*Wallet) ChangePrivatePassphrase 

func (w *Wallet) ChangePrivatePassphrase(ctx context.Context, old, new []byte) error

ChangePrivatePassphrase attempts to change the passphrase for a wallet from old to new. Changing the passphrase is synchronized with all other address manager locking and unlocking. The lock state will be the same as it was before the password change.

func (*Wallet) ChangePublicPassphrase 

func (w *Wallet) ChangePublicPassphrase(ctx context.Context, old, new []byte) error

ChangePublicPassphrase modifies the public passphrase of the wallet.

func (*Wallet) CoinType 

func (w *Wallet) CoinType(ctx context.Context) (uint32, error)

CoinType returns the active BIP0044 coin type. For watching-only wallets, which do not save the coin type keys, this method will return an error with code errors.WatchingOnly.

func (*Wallet) CoinTypePrivKey 

func (w *Wallet) CoinTypePrivKey(ctx context.Context) (*hdkeychain.ExtendedKey, error)

CoinTypePrivKey returns the BIP0044 coin type private key.

func (*Wallet) CommittedTickets 

func (w *Wallet) CommittedTickets(ctx context.Context, tickets []*chainhash.Hash) ([]*chainhash.Hash, []dcrutil.Address, error)

CommittedTickets takes a list of tickets and returns a filtered list of tickets that are controlled by this wallet.

func (*Wallet) Consolidate 

func (w *Wallet) Consolidate(ctx context.Context, inputs int, account uint32, address dcrutil.Address) (*chainhash.Hash, error)

Consolidate consolidates as many UTXOs as are passed in the inputs argument. If that many UTXOs can not be found, it will use the maximum it finds. This will only compress UTXOs in the default account

func (*Wallet) CreateMultisigTx 

func (w *Wallet) CreateMultisigTx(ctx context.Context, account uint32, amount dcrutil.Amount,
	pubkeys []*dcrutil.AddressSecpPubKey, nrequired int8, minconf int32) (*CreatedTx, dcrutil.Address, []byte, error)

CreateMultisigTx creates and signs a multisig transaction.

func (*Wallet) CreateSignature 

func (w *Wallet) CreateSignature(ctx context.Context, tx *wire.MsgTx, idx uint32, addr dcrutil.Address,
	hashType txscript.SigHashType, prevPkScript []byte) (sig, pubkey []byte, err error)

CreateSignature returns the raw signature created by the private key of addr for tx's idx'th input script and the serialized compressed pubkey for the address.

func (*Wallet) CurrentAddress 

func (w *Wallet) CurrentAddress(account uint32) (dcrutil.Address, error)

CurrentAddress gets the most recently requested payment address from a wallet. If the address has already been used (there is at least one transaction spending to it in the blockchain or dcrd mempool), the next chained address is returned.

func (*Wallet) DiscoverActiveAddresses 

func (w *Wallet) DiscoverActiveAddresses(ctx context.Context, p Peer, startBlock *chainhash.Hash, discoverAccts bool) error

DiscoverActiveAddresses searches for future wallet address usage in all blocks starting from startBlock. If discoverAccts is true, used accounts will be discovered as well. This feature requires the wallet to be unlocked in order to derive hardened account extended pubkeys.

If the wallet is currently on the legacy coin type and no address or account usage is observed and coin type upgrades are not disabled, the wallet will be upgraded to the SLIP0044 coin type and the address discovery will occur again.

func (*Wallet) DumpWIFPrivateKey 

func (w *Wallet) DumpWIFPrivateKey(ctx context.Context, addr dcrutil.Address) (string, error)

DumpWIFPrivateKey returns the WIF encoded private key for a single wallet address.

func (*Wallet) EvaluateBestChain 

func (w *Wallet) EvaluateBestChain(ctx context.Context, f *SidechainForest) ([]*BlockNode, error)

EvaluateBestChain returns block nodes to create the best main chain. These may extend the main chain or require a reorg. An empty slice indicates there is no better chain.

func (*Wallet) FetchAllRedeemScripts 

func (w *Wallet) FetchAllRedeemScripts(ctx context.Context) ([][]byte, error)

FetchAllRedeemScripts returns all P2SH redeem scripts saved by the wallet.

func (*Wallet) FetchHeaders 

func (w *Wallet) FetchHeaders(ctx context.Context, p Peer) (count int, rescanFrom chainhash.Hash, rescanFromHeight int32, mainChainTipBlockHash chainhash.Hash, mainChainTipBlockHeight int32, err error)

FetchHeaders fetches headers from a Peer and updates the main chain tip with the latest block. The number of new headers fetched is returned, along with the hash of the first previously-unseen block hash now in the main chain. This is the block a rescan should begin at (inclusive), and is only relevant when the number of fetched headers is not zero.

func (*Wallet) FetchMissingCFilters 

func (w *Wallet) FetchMissingCFilters(ctx context.Context, p Peer) error

FetchMissingCFilters records any missing compact filters for main chain blocks. A database upgrade requires all compact filters to be recorded for the main chain before any more blocks may be attached, but this information must be fetched at runtime after the upgrade as it is not already known at the time of upgrade.

func (*Wallet) FetchMissingCFiltersWithProgress 

func (w *Wallet) FetchMissingCFiltersWithProgress(ctx context.Context, p Peer, progress chan<- MissingCFilterProgress)

FetchMissingCFiltersWithProgress records any missing compact filters for main chain blocks. A database upgrade requires all compact filters to be recorded for the main chain before any more blocks may be attached, but this information must be fetched at runtime after the upgrade as it is not already known at the time of upgrade. This function reports to a channel with any progress that may have seen.

func (*Wallet) FetchOutput 

func (w *Wallet) FetchOutput(ctx context.Context, outPoint *wire.OutPoint) (*wire.TxOut, error)

FetchOutput fetches the associated transaction output given an outpoint. It cannot be used to fetch multi-signature outputs.

func (*Wallet) FetchP2SHMultiSigOutput 

func (w *Wallet) FetchP2SHMultiSigOutput(ctx context.Context, outPoint *wire.OutPoint) (*P2SHMultiSigOutput, error)

FetchP2SHMultiSigOutput fetches information regarding a wallet's P2SH multi-signature output.

func (*Wallet) FindEligibleOutputs 

func (w *Wallet) FindEligibleOutputs(ctx context.Context, account uint32, minconf int32, currentHeight int32) ([]udb.Credit, error)

FindEligibleOutputs is the exported version of findEligibleOutputs (which tried to find unspent outputs that pass a maturity check).

func (*Wallet) GenerateVoteTx 

func (w *Wallet) GenerateVoteTx(ctx context.Context, blockHash *chainhash.Hash, height int32,
	ticketHash *chainhash.Hash, voteBits stake.VoteBits) (*wire.MsgTx, error)

GenerateVoteTx creates a vote transaction for a chosen ticket purchase hash using the provided votebits. The ticket purchase transaction must be stored by the wallet.

func (*Wallet) GetTicketInfo 

func (w *Wallet) GetTicketInfo(ctx context.Context, hash *chainhash.Hash) (*TicketSummary, *wire.BlockHeader, error)

GetTicketInfo returns the ticket summary and the corresponding block header for the provided ticket. The ticket summary is comprised of the transaction summmary for the ticket, the spender (if already spent) and the ticket's current status.

If the ticket is unmined, then the returned block header will be nil.

func (*Wallet) GetTicketInfoPrecise 

func (w *Wallet) GetTicketInfoPrecise(ctx context.Context, rpcCaller Caller, hash *chainhash.Hash) (*TicketSummary, *wire.BlockHeader, error)

GetTicketInfoPrecise returns the ticket summary and the corresponding block header for the provided ticket. The ticket summary is comprised of the transaction summmary for the ticket, the spender (if already spent) and the ticket's current status.

If the ticket is unmined, then the returned block header will be nil.

The argument chainClient is always expected to be not nil in this case, otherwise one should use the alternative GetTicketInfo instead. With the ability to use the rpc chain client, this function is able to determine whether a ticket has been missed or not. Otherwise, it is just known to be unspent (possibly live or missed).

func (*Wallet) GetTickets 

func (w *Wallet) GetTickets(ctx context.Context, f func([]*TicketSummary, *wire.BlockHeader) (bool, error), startBlock, endBlock *BlockIdentifier) error

GetTickets calls function f for all tickets located in between the given startBlock and endBlock. TicketSummary includes TransactionSummmary for the ticket and the spender (if already spent) and the ticket's current status. The function f also receives block header of the ticket. All tickets on a given call belong to the same block and at least one ticket is present when f is called. If the ticket is unmined, the block header will be nil.

The function f may return an error which, if non-nil, is propagated to the caller. Additionally, a boolean return value allows exiting the function early without reading any additional transactions when true.

The arguments to f may be reused and should not be kept by the caller.

Because this function does not have any chain client argument, tickets are unable to be determined whether or not they have been missed, simply unspent.

func (*Wallet) GetTicketsPrecise 

func (w *Wallet) GetTicketsPrecise(ctx context.Context, rpcCaller Caller,
	f func([]*TicketSummary, *wire.BlockHeader) (bool, error), startBlock, endBlock *BlockIdentifier) error

GetTicketsPrecise calls function f for all tickets located in between the given startBlock and endBlock. TicketSummary includes TransactionSummmary for the ticket and the spender (if already spent) and the ticket's current status. The function f also receives block header of the ticket. All tickets on a given call belong to the same block and at least one ticket is present when f is called. If the ticket is unmined, the block header will be nil.

The function f may return an error which, if non-nil, is propagated to the caller. Additionally, a boolean return value allows exiting the function early without reading any additional transactions when true.

The arguments to f may be reused and should not be kept by the caller.

The argument chainClient is always expected to be not nil in this case, otherwise one should use the alternative GetTickets instead. With the ability to use the rpc chain client, this function is able to determine whether tickets have been missed or not. Otherwise, tickets are just known to be unspent (possibly live or missed).

func (*Wallet) GetTransactions 

func (w *Wallet) GetTransactions(ctx context.Context, f func(*Block) (bool, error), startBlock, endBlock *BlockIdentifier) error

GetTransactions runs the function f on all transactions between a starting and ending block. Blocks in the block range may be specified by either a height or a hash.

The function f may return an error which, if non-nil, is propagated to the caller. Additionally, a boolean return value allows exiting the function early without reading any additional transactions when true.

Transaction results are organized by blocks in ascending order and unmined transactions in an unspecified order. Mined transactions are saved in a Block structure which records properties about the block. Unmined transactions are returned on a Block structure with height == -1.

Internally this function uses the udb store RangeTransactions function, therefore the notes and restrictions of that function also apply here.

func (*Wallet) GetTransactionsByHashes 

func (w *Wallet) GetTransactionsByHashes(ctx context.Context, txHashes []*chainhash.Hash) (txs []*wire.MsgTx, notFound []*wire.InvVect, err error)

GetTransactionsByHashes returns all known transactions identified by a slice of transaction hashes. It is possible that not all transactions are found, and in this case the known results will be returned along with an inventory vector of all missing transactions and an error with code NotExist.

func (*Wallet) HaveAddress 

func (w *Wallet) HaveAddress(ctx context.Context, a dcrutil.Address) (bool, error)

HaveAddress returns whether the wallet is the owner of the address a.

func (*Wallet) ImportP2SHRedeemScript 

func (w *Wallet) ImportP2SHRedeemScript(ctx context.Context, script []byte) (*dcrutil.AddressScriptHash, error)

ImportP2SHRedeemScript adds a P2SH redeem script to the wallet.

func (*Wallet) ImportPrivateKey 

func (w *Wallet) ImportPrivateKey(ctx context.Context, wif *dcrutil.WIF) (string, error)

ImportPrivateKey imports a private key to the wallet and writes the new wallet to disk.

func (*Wallet) ImportScript 

func (w *Wallet) ImportScript(ctx context.Context, rs []byte) error

ImportScript imports a redeemscript to the wallet. If it also allows the user to specify whether or not they want the redeemscript to be rescanned, and how far back they wish to rescan.

func (*Wallet) ImportXpubAccount 

func (w *Wallet) ImportXpubAccount(ctx context.Context, name string, xpub *hdkeychain.ExtendedKey) error

func (*Wallet) ListAddressTransactions 

func (w *Wallet) ListAddressTransactions(ctx context.Context, pkHashes map[string]struct{}) ([]types.ListTransactionsResult, error)

ListAddressTransactions returns a slice of objects with details about recorded transactions to or from any address belonging to a set. This is intended to be used for listaddresstransactions RPC replies.

func (*Wallet) ListAllTransactions 

func (w *Wallet) ListAllTransactions(ctx context.Context) ([]types.ListTransactionsResult, error)

ListAllTransactions returns a slice of objects with details about a recorded transaction. This is intended to be used for listalltransactions RPC replies.

func (*Wallet) ListSinceBlock 

func (w *Wallet) ListSinceBlock(ctx context.Context, start, end, syncHeight int32) ([]types.ListTransactionsResult, error)

ListSinceBlock returns a slice of objects with details about transactions since the given block. If the block is -1 then all transactions are included. This is intended to be used for listsinceblock RPC replies.

func (*Wallet) ListTransactionDetails 

func (w *Wallet) ListTransactionDetails(ctx context.Context, txHash *chainhash.Hash) ([]types.ListTransactionsResult, error)

ListTransactionDetails returns the listtransaction results for a single transaction.

func (*Wallet) ListTransactions 

func (w *Wallet) ListTransactions(ctx context.Context, from, count int) ([]types.ListTransactionsResult, error)

ListTransactions returns a slice of objects with details about a recorded transaction. This is intended to be used for listtransactions RPC replies.

func (*Wallet) ListUnspent 

func (w *Wallet) ListUnspent(ctx context.Context, minconf, maxconf int32, addresses map[string]struct{}) ([]*types.ListUnspentResult, error)

ListUnspent returns a slice of objects representing the unspent wallet transactions fitting the given criteria. The confirmations will be more than minconf, less than maxconf and if addresses is populated only the addresses contained within it will be considered. If we know nothing about a transaction an empty array will be returned.

func (*Wallet) LiveTicketHashes 

func (w *Wallet) LiveTicketHashes(ctx context.Context, rpcCaller Caller, includeImmature bool) ([]chainhash.Hash, error)

LiveTicketHashes returns the hashes of live tickets that the wallet has purchased or has voting authority for.

func (*Wallet) LoadActiveDataFilters 

func (w *Wallet) LoadActiveDataFilters(ctx context.Context, n NetworkBackend, reload bool) (err error)

LoadActiveDataFilters loads filters for all active addresses and unspent outpoints for this wallet.

func (*Wallet) Lock 

func (w *Wallet) Lock()

Lock locks the wallet's address manager.

func (*Wallet) LockOutpoint 

func (w *Wallet) LockOutpoint(op wire.OutPoint)

LockOutpoint marks an outpoint as locked, that is, it should not be used as an input for newly created transactions.

func (*Wallet) Locked 

func (w *Wallet) Locked() bool

Locked returns whether the account manager for a wallet is locked.

func (*Wallet) LockedOutpoint 

func (w *Wallet) LockedOutpoint(op wire.OutPoint) bool

LockedOutpoint returns whether an outpoint has been marked as locked and should not be used as an input for created transactions.

func (*Wallet) LockedOutpoints 

func (w *Wallet) LockedOutpoints() []dcrdtypes.TransactionInput

LockedOutpoints returns a slice of currently locked outpoints. This is intended to be used by marshaling the result as a JSON array for listlockunspent RPC results.

func (*Wallet) MainChainTip 

func (w *Wallet) MainChainTip(ctx context.Context) (hash chainhash.Hash, height int32)

MainChainTip returns the hash and height of the tip-most block in the main chain that the wallet is synchronized to.

func (*Wallet) MakeSecp256k1MultiSigScript 

func (w *Wallet) MakeSecp256k1MultiSigScript(ctx context.Context, secp256k1Addrs []dcrutil.Address, nRequired int) ([]byte, error)

MakeSecp256k1MultiSigScript creates a multi-signature script that can be redeemed with nRequired signatures of the passed keys and addresses. If the address is a P2PKH address, the associated pubkey is looked up by the wallet if possible, otherwise an error is returned for a missing pubkey.

This function only works with secp256k1 pubkeys and P2PKH addresses derived from them.

func (*Wallet) MasterPrivKey 

func (w *Wallet) MasterPrivKey(ctx context.Context, account uint32) (*hdkeychain.ExtendedKey, error)

MasterPrivKey returns the extended private key for the given account. The account must exist and the wallet must be unlocked, otherwise this function fails.

func (*Wallet) MasterPubKey 

func (w *Wallet) MasterPubKey(ctx context.Context, account uint32) (*hdkeychain.ExtendedKey, error)

MasterPubKey returns the BIP0044 master public key for the passed account.

func (*Wallet) MixAccount 

func (w *Wallet) MixAccount(ctx context.Context, dialTLS DialFunc, csppserver string, changeAccount, mixAccount, mixBranch uint32) error

MixAccount individually mixes outputs of an account into standard denominations, creating newly mixed outputs for a mixed account.

Due to performance concerns of timing out in a CoinShuffle++ run, this function may throttle how many of the outputs are mixed each call.

func (*Wallet) MixOutput 

func (w *Wallet) MixOutput(ctx context.Context, dialTLS DialFunc, csppserver string, output *wire.OutPoint, changeAccount, mixAccount, mixBranch uint32) error

func (*Wallet) NeedsAccountsSync 

func (w *Wallet) NeedsAccountsSync(ctx context.Context) (bool, error)

NeedsAccountsSync returns whether or not the wallet is void of any generated keys and accounts (other than the default account), and records the genesis block as the main chain tip. When these are both true, an accounts sync should be performed to restore, per BIP0044, any generated accounts and addresses from a restored seed.

func (*Wallet) NetworkBackend 

func (w *Wallet) NetworkBackend() (NetworkBackend, error)

NetworkBackend returns the currently associated network backend of the wallet, or an error if the no backend is currently set.

func (*Wallet) NewChangeAddress 

func (w *Wallet) NewChangeAddress(ctx context.Context, account uint32) (dcrutil.Address, error)

NewChangeAddress returns an internal address. This is identical to NewInternalAddress but handles the imported account (which can't create addresses) by using account 0 instead, and always uses the wrapping gap limit policy.

func (*Wallet) NewExternalAddress 

func (w *Wallet) NewExternalAddress(ctx context.Context, account uint32, callOpts ...NextAddressCallOption) (dcrutil.Address, error)

NewExternalAddress returns an external address.

func (*Wallet) NewInternalAddress 

func (w *Wallet) NewInternalAddress(ctx context.Context, account uint32, callOpts ...NextAddressCallOption) (dcrutil.Address, error)

NewInternalAddress returns an internal address.

func (*Wallet) NewUnsignedTransaction 

func (w *Wallet) NewUnsignedTransaction(ctx context.Context, outputs []*wire.TxOut,
	relayFeePerKb dcrutil.Amount, account uint32, minConf int32,
	algo OutputSelectionAlgorithm, changeSource txauthor.ChangeSource) (*txauthor.AuthoredTx, error)

NewUnsignedTransaction constructs an unsigned transaction using unspent account outputs.

The changeSource parameter is optional and can be nil. When nil, and if a change output should be added, an internal change address is created for the account.

func (*Wallet) NextAccount 

func (w *Wallet) NextAccount(ctx context.Context, name string) (uint32, error)

NextAccount creates the next account and returns its account number. The name must be unique to the account. In order to support automatic seed restoring, new accounts may not be created when all of the previous 100 accounts have no transaction history (this is a deviation from the BIP0044 spec, which allows no unused account gaps).

func (*Wallet) NextStakeDifficulty 

func (w *Wallet) NextStakeDifficulty(ctx context.Context) (dcrutil.Amount, error)

NextStakeDifficulty returns the ticket price for the next block after the current main chain tip block. This function only succeeds when DCP0001 is known to be active. As a fallback, the StakeDifficulty method of wallet.NetworkBackend may be used to query the next ticket price from a trusted full node.

func (*Wallet) NextStakeDifficultyAfterHeader 

func (w *Wallet) NextStakeDifficultyAfterHeader(ctx context.Context, h *wire.BlockHeader) (dcrutil.Amount, error)

NextStakeDifficultyAfterHeader returns the ticket price for the child of h. All headers of ancestor blocks of h must be recorded by the wallet. This function only succeeds when DCP0001 is known to be active.

func (*Wallet) OutputInfo 

func (w *Wallet) OutputInfo(ctx context.Context, out *wire.OutPoint) (OutputInfo, error)

OutputInfo queries the wallet for additional transaction output info regarding an outpoint.

func (*Wallet) PoolAddress 

func (w *Wallet) PoolAddress() dcrutil.Address

PoolAddress gets the pool address for the wallet to give ticket fees to.

func (*Wallet) PoolFees 

func (w *Wallet) PoolFees() float64

PoolFees gets the per-ticket pool fee for the wallet.

func (*Wallet) PrepareRedeemMultiSigOutTxOutput 

func (w *Wallet) PrepareRedeemMultiSigOutTxOutput(msgTx *wire.MsgTx, p2shOutput *P2SHMultiSigOutput, pkScript *[]byte) error

PrepareRedeemMultiSigOutTxOutput estimates the tx value for a MultiSigOutTx output and adds it to msgTx.

func (*Wallet) PubKeyForAddress 

func (w *Wallet) PubKeyForAddress(ctx context.Context, a dcrutil.Address) (chainec.PublicKey, error)

PubKeyForAddress looks up the associated public key for a P2PKH address.

func (*Wallet) PublishTransaction 

func (w *Wallet) PublishTransaction(ctx context.Context, tx *wire.MsgTx, serializedTx []byte, n NetworkBackend) (*chainhash.Hash, error)

PublishTransaction saves (if relevant) and sends the transaction to the consensus RPC server so it can be propagated to other nodes and eventually mined. If the send fails, the transaction is not added to the wallet.

func (*Wallet) PublishUnminedTransactions 

func (w *Wallet) PublishUnminedTransactions(ctx context.Context, p Peer) error

PublishUnminedTransactions rebroadcasts all unmined transactions to the consensus RPC server so it can be propagated to other nodes and eventually mined.

func (*Wallet) PurchaseTickets deprecated 

func (w *Wallet) PurchaseTickets(ctx context.Context, minBalance, spendLimit dcrutil.Amount, minConf int32,
	votingAddr dcrutil.Address, account uint32, count int, poolAddress dcrutil.Address,
	poolFees float64, expiry int32, txFee dcrutil.Amount, ticketFee dcrutil.Amount) ([]*chainhash.Hash, error)

PurchaseTickets purchases tickets, returning the hashes of all ticket purchase transactions.

Deprecated: Use PurchaseTicketsContext.

func (*Wallet) PurchaseTicketsContext 

func (w *Wallet) PurchaseTicketsContext(ctx context.Context, n NetworkBackend, req *PurchaseTicketsRequest) ([]*chainhash.Hash, error)

PurchaseTicketsContext purchases tickets, returning the hashes of all ticket purchase transactions.

func (*Wallet) RedeemScriptCopy 

func (w *Wallet) RedeemScriptCopy(ctx context.Context, addr dcrutil.Address) ([]byte, error)

RedeemScriptCopy returns a copy of a redeem script to redeem outputs paid to a P2SH address.

func (*Wallet) RelayFee 

func (w *Wallet) RelayFee() dcrutil.Amount

RelayFee returns the current minimum relay fee (per kB of serialized transaction) used when constructing transactions.

func (*Wallet) RenameAccount 

func (w *Wallet) RenameAccount(ctx context.Context, account uint32, newName string) error

RenameAccount sets the name for an account number to newName.

func (*Wallet) Rescan 

func (w *Wallet) Rescan(ctx context.Context, n NetworkBackend, startHash *chainhash.Hash) error

Rescan starts a rescan of the wallet for all blocks on the main chain beginning at startHash. This function blocks until the rescan completes.

func (*Wallet) RescanFromHeight 

func (w *Wallet) RescanFromHeight(ctx context.Context, n NetworkBackend, startHeight int32) error

RescanFromHeight is an alternative to Rescan that takes a block height instead of a hash. See Rescan for more details.

func (*Wallet) RescanPoint 

func (w *Wallet) RescanPoint(ctx context.Context) (*chainhash.Hash, error)

RescanPoint returns the block hash at which a rescan should begin (inclusive), or nil when no rescan is necessary.

func (*Wallet) RescanProgressFromHeight 

func (w *Wallet) RescanProgressFromHeight(ctx context.Context, n NetworkBackend,
	startHeight int32, p chan<- RescanProgress)

RescanProgressFromHeight rescans for relevant transactions in all blocks in the main chain starting at startHeight. Progress notifications and any errors are sent to the channel p. This function blocks until the rescan completes or ends in an error. p is closed before returning.

func (*Wallet) ResetLockedOutpoints 

func (w *Wallet) ResetLockedOutpoints()

ResetLockedOutpoints resets the set of locked outpoints so all may be used as inputs for new transactions.

func (*Wallet) RevokeExpiredTickets 

func (w *Wallet) RevokeExpiredTickets(ctx context.Context, p Peer) (err error)

RevokeExpiredTickets revokes any unspent tickets that cannot be live due to being past expiry. It is similar to RevokeTickets but is able to be used with any Peer implementation as it will not query the consensus RPC server for missed tickets.

func (*Wallet) RevokeOwnedTickets 

func (w *Wallet) RevokeOwnedTickets(ctx context.Context, missedTicketHashes []*chainhash.Hash) error

RevokeOwnedTickets revokes any owned tickets specified in the missedTicketHashes slice. When a network backend is associated with the wallet, relevant commitment outputs are loaded as watched data.

func (*Wallet) RevokeTickets 

func (w *Wallet) RevokeTickets(ctx context.Context, rpcCaller Caller) error

RevokeTickets creates and sends revocation transactions for any unrevoked missed and expired tickets. The wallet must be unlocked to generate any revocations.

func (*Wallet) SaveRescanned 

func (w *Wallet) SaveRescanned(ctx context.Context, hash *chainhash.Hash, txs []*wire.MsgTx) error

SaveRescanned records transactions from a rescanned block. This does not update the network backend with data to watch for future relevant transactions as the rescanner is assumed to handle this task.

func (*Wallet) SelectInputs 

func (w *Wallet) SelectInputs(ctx context.Context, targetAmount dcrutil.Amount, policy OutputSelectionPolicy) (inputDetail *txauthor.InputDetail, err error)

SelectInputs selects transaction inputs to redeem unspent outputs stored in the wallet. It returns an input detail summary.

func (*Wallet) SendOutputs 

func (w *Wallet) SendOutputs(ctx context.Context, outputs []*wire.TxOut, account, changeAccount uint32, minconf int32) (*chainhash.Hash, error)

SendOutputs creates and sends payment transactions. It returns the transaction hash upon success

func (*Wallet) SetAgendaChoices 

func (w *Wallet) SetAgendaChoices(ctx context.Context, choices ...AgendaChoice) (voteBits uint16, err error)

SetAgendaChoices sets the choices for agendas defined by the supported stake version. If a choice is set multiple times, the last takes preference. The new votebits after each change is made are returned.

func (*Wallet) SetBalanceToMaintain 

func (w *Wallet) SetBalanceToMaintain(balance dcrutil.Amount)

SetBalanceToMaintain is used to set the current w.balancetomaintain for the wallet.

func (*Wallet) SetNetworkBackend 

func (w *Wallet) SetNetworkBackend(n NetworkBackend)

SetNetworkBackend sets the network backend used by various functions of the wallet.

func (*Wallet) SetRelayFee 

func (w *Wallet) SetRelayFee(relayFee dcrutil.Amount)

SetRelayFee sets a new minimum relay fee (per kB of serialized transaction) used when constructing transactions.

func (*Wallet) SetTicketFeeIncrement 

func (w *Wallet) SetTicketFeeIncrement(fee dcrutil.Amount)

SetTicketFeeIncrement is used to set the current w.ticketFeeIncrement for the wallet.

func (*Wallet) SignMessage 

func (w *Wallet) SignMessage(ctx context.Context, msg string, addr dcrutil.Address) (sig []byte, err error)

SignMessage returns the signature of a signed message using an address' associated private key.

func (*Wallet) SignTransaction 

func (w *Wallet) SignTransaction(ctx context.Context, tx *wire.MsgTx, hashType txscript.SigHashType, additionalPrevScripts map[wire.OutPoint][]byte,
	additionalKeysByAddress map[string]*dcrutil.WIF, p2shRedeemScriptsByAddress map[string][]byte) ([]SignatureError, error)

SignTransaction uses secrets of the wallet, as well as additional secrets passed in by the caller, to create and add input signatures to a transaction.

Transaction input script validation is used to confirm that all signatures are valid. For any invalid input, a SignatureError is added to the returns. The final error return is reserved for unexpected or fatal errors, such as being unable to determine a previous output script to redeem.

The transaction pointed to by tx is modified by this function.

func (*Wallet) SortedActivePaymentAddresses 

func (w *Wallet) SortedActivePaymentAddresses(ctx context.Context) ([]string, error)

SortedActivePaymentAddresses returns a slice of all active payment addresses in a wallet.

func (*Wallet) StakeInfo 

func (w *Wallet) StakeInfo(ctx context.Context) (*StakeInfoData, error)

StakeInfo collects and returns staking statistics for this wallet.

func (*Wallet) StakeInfoPrecise 

func (w *Wallet) StakeInfoPrecise(ctx context.Context, rpcCaller Caller) (*StakeInfoData, error)

StakeInfoPrecise collects and returns staking statistics for this wallet. It uses RPC to query further information than StakeInfo.

func (*Wallet) StakePoolUserInfo 

func (w *Wallet) StakePoolUserInfo(ctx context.Context, userAddress dcrutil.Address) (*udb.StakePoolUser, error)

StakePoolUserInfo returns the stake pool user information for a user identified by their P2SH voting address.

func (*Wallet) SyncLastReturnedAddress 

func (w *Wallet) SyncLastReturnedAddress(ctx context.Context, account, branch, child uint32) error

SyncLastReturnedAddress advances the last returned child address for a BIP00044 account branch. The next returned address for the branch will be child+1.

func (*Wallet) TicketAddress 

func (w *Wallet) TicketAddress() dcrutil.Address

TicketAddress gets the ticket address for the wallet to give the ticket voting rights to.

func (*Wallet) TicketFeeIncrement 

func (w *Wallet) TicketFeeIncrement() dcrutil.Amount

TicketFeeIncrement is used to get the current feeIncrement for the wallet.

func (*Wallet) TicketHashesForVotingAddress 

func (w *Wallet) TicketHashesForVotingAddress(ctx context.Context, votingAddr dcrutil.Address) ([]chainhash.Hash, error)

TicketHashesForVotingAddress returns the hashes of all tickets with voting rights delegated to votingAddr. This function does not return the hashes of pruned tickets.

func (*Wallet) TotalReceivedForAccounts 

func (w *Wallet) TotalReceivedForAccounts(ctx context.Context, minConf int32) ([]AccountTotalReceivedResult, error)

TotalReceivedForAccounts iterates through a wallet's transaction history, returning the total amount of decred received for all accounts.

func (*Wallet) TotalReceivedForAddr 

func (w *Wallet) TotalReceivedForAddr(ctx context.Context, addr dcrutil.Address, minConf int32) (dcrutil.Amount, error)

TotalReceivedForAddr iterates through a wallet's transaction history, returning the total amount of decred received for a single wallet address.

func (*Wallet) TransactionSummary 

func (w *Wallet) TransactionSummary(ctx context.Context, txHash *chainhash.Hash) (txSummary *TransactionSummary, confs int32, blockHash *chainhash.Hash, err error)

TransactionSummary returns details about a recorded transaction that is relevant to the wallet in some way.

func (*Wallet) Unlock 

func (w *Wallet) Unlock(ctx context.Context, passphrase []byte, timeout <-chan time.Time) error

Unlock unlocks the wallet, allowing access to private keys and secret scripts. An unlocked wallet will be locked before returning with a Passphrase error if the passphrase is incorrect. If the wallet is currently unlocked without any timeout, timeout is ignored and read in a background goroutine to avoid blocking sends. If the wallet is locked and a non-nil timeout is provided, the wallet will be locked in the background after reading from the channel. If the wallet is already unlocked with a previous timeout, the new timeout replaces the prior.

func (*Wallet) UnlockOutpoint 

func (w *Wallet) UnlockOutpoint(op wire.OutPoint)

UnlockOutpoint marks an outpoint as unlocked, that is, it may be used as an input for newly created transactions.

func (*Wallet) UnminedTransactions 

func (w *Wallet) UnminedTransactions(ctx context.Context) ([]*wire.MsgTx, error)

UnminedTransactions returns all unmined transactions from the wallet. Transactions are sorted in dependency order making it suitable to range them in order to broadcast at wallet startup.

func (*Wallet) UnspentOutputs 

func (w *Wallet) UnspentOutputs(ctx context.Context, policy OutputSelectionPolicy) ([]*TransactionOutput, error)

UnspentOutputs fetches all unspent outputs from the wallet that match rules described in the passed policy.

func (*Wallet) UpgradeToSLIP0044CoinType 

func (w *Wallet) UpgradeToSLIP0044CoinType(ctx context.Context) error

UpgradeToSLIP0044CoinType upgrades the wallet from the legacy BIP0044 coin type to one of the coin types assigned to Decred in SLIP0044. This should be called after a new wallet is created with a random (not imported) seed.

This function does not register addresses from the new account 0 with the wallet's network backend. This is intentional as it allows offline activities, such as wallet creation, to perform this upgrade.

func (*Wallet) ValidateHeaderChainDifficulties 

func (w *Wallet) ValidateHeaderChainDifficulties(ctx context.Context, chain []*BlockNode, idx int) ([]*BlockNode, error)

ValidateHeaderChainDifficulties validates the PoW and PoS difficulties of all blocks in chain[idx:]. The parent of chain[0] must be recorded as wallet main chain block. If a consensus violation is caught, a subslice of chain beginning with the invalid block is returned.

func (*Wallet) VoteBits 

func (w *Wallet) VoteBits() stake.VoteBits

VoteBits returns the vote bits that are described by the currently set agenda preferences. The previous block valid bit is always set, and must be unset elsewhere if the previous block's regular transactions should be voted against.

func (*Wallet) VoteOnOwnedTickets 

func (w *Wallet) VoteOnOwnedTickets(ctx context.Context, winningTicketHashes []*chainhash.Hash, blockHash *chainhash.Hash, blockHeight int32) error

VoteOnOwnedTickets creates and publishes vote transactions for all owned tickets in the winningTicketHashes slice if wallet voting is enabled. The vote is only valid when voting on the block described by the passed block hash and height. When a network backend is associated with the wallet, relevant commitment outputs are loaded as watched data.

func (*Wallet) VotingEnabled 

func (w *Wallet) VotingEnabled() bool

VotingEnabled returns whether the wallet is configured to vote tickets.

Source Files

View all Source files

Directories

Path Synopsis
drivers
bdb
Package bdb registers the bdb driver at init time.
 Package bdb registers the bdb driver at init time.
internal
bdb
Package bdb implements an instance of walletdb that uses boltdb for the backing datastore.
 Package bdb implements an instance of walletdb that uses boltdb for the backing datastore.
compat
snacl
Package txauthor provides transaction creation code for wallets.
 Package txauthor provides transaction creation code for wallets.
Package txrules provides functions that are help establish whether or not a transaction abides by non-consensus rules for things like the daemon and stake pool.
 Package txrules provides functions that are help establish whether or not a transaction abides by non-consensus rules for things like the daemon and stake pool.
Package walletdb provides a namespaced database interface for dcrwallet.
 Package walletdb provides a namespaced database interface for dcrwallet.

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.