README

btcjson

Build Status ISC License GoDoc

Package btcjson implements concrete types for marshalling to and from the bitcoin JSON-RPC API. A comprehensive suite of tests is provided to ensure proper functionality.

Although this package was primarily written for the btcsuite, it has intentionally been designed so it can be used as a standalone package for any projects needing to marshal to and from bitcoin JSON-RPC requests and responses.

Note that although it's possible to use this package directly to implement an RPC client, it is not recommended since it is only intended as an infrastructure package. Instead, RPC clients should use the btcrpcclient package which provides a full blown RPC client with many features such as automatic connection management, websocket support, automatic notification re-registration on reconnect, and conversion from the raw underlying RPC types (strings, floats, ints, etc) to higher-level types with many nice and useful properties.

Installation and Updating

$ go get -u github.com/gcash/bchd/btcjson

Examples

  • Marshal Command
    Demonstrates how to create and marshal a command into a JSON-RPC request.

  • Unmarshal Command
    Demonstrates how to unmarshal a JSON-RPC request and then unmarshal the concrete request into a concrete command.

  • Marshal Response
    Demonstrates how to marshal a JSON-RPC response.

  • Unmarshal Response
    Demonstrates how to unmarshal a JSON-RPC response and then unmarshal the result field in the response to a concrete type.

GPG Verification Key

All official release tags are signed by Conformal so users can ensure the code has not been tampered with and is coming from the btcsuite developers. To verify the signature perform the following:

  • Download the public key from the Conformal website at https://opensource.conformal.com/GIT-GPG-KEY-conformal.txt

  • Import the public key into your GPG keyring:

    gpg --import GIT-GPG-KEY-conformal.txt
    
  • Verify the release tag with the following command where TAG_NAME is a placeholder for the specific tag:

    git tag -v TAG_NAME
    

License

Package btcjson is licensed under the copyfree ISC License.

Expand ▾ Collapse ▴

Documentation

Overview

Package btcjson provides primitives for working with the bitcoin JSON-RPC API.

Overview

When communicating via the JSON-RPC protocol, all of the commands need to be marshalled to and from the the wire in the appropriate format. This package provides data structures and primitives to ease this process.

In addition, it also provides some additional features such as custom command registration, command categorization, and reflection-based help generation.

JSON-RPC Protocol Overview

This information is not necessary in order to use this package, but it does provide some intuition into what the marshalling and unmarshalling that is discussed below is doing under the hood.

As defined by the JSON-RPC spec, there are effectively two forms of messages on the wire:

- Request Objects
  {"jsonrpc":"1.0","id":"SOMEID","method":"SOMEMETHOD","params":[SOMEPARAMS]}
  NOTE: Notifications are the same format except the id field is null.

- Response Objects
  {"result":SOMETHING,"error":null,"id":"SOMEID"}
  {"result":null,"error":{"code":SOMEINT,"message":SOMESTRING},"id":"SOMEID"}

For requests, the params field can vary in what it contains depending on the method (a.k.a. command) being sent. Each parameter can be as simple as an int or a complex structure containing many nested fields. The id field is used to identify a request and will be included in the associated response.

When working with asynchronous transports, such as websockets, spontaneous notifications are also possible. As indicated, they are the same as a request object, except they have the id field set to null. Therefore, servers will ignore requests with the id field set to null, while clients can choose to consume or ignore them.

Unfortunately, the original Bitcoin JSON-RPC API (and hence anything compatible with it) doesn't always follow the spec and will sometimes return an error string in the result field with a null error for certain commands. However, for the most part, the error field will be set as described on failure.

Marshalling and Unmarshalling

Based upon the discussion above, it should be easy to see how the types of this package map into the required parts of the protocol

- Request Objects (type Request)
  - Commands (type <Foo>Cmd)
  - Notifications (type <Foo>Ntfn)
- Response Objects (type Response)
  - Result (type <Foo>Result)

To simplify the marshalling of the requests and responses, the MarshalCmd and MarshalResponse functions are provided. They return the raw bytes ready to be sent across the wire.

Unmarshalling a received Request object is a two step process:

1) Unmarshal the raw bytes into a Request struct instance via json.Unmarshal
2) Use UnmarshalCmd on the Result field of the unmarshalled Request to create
   a concrete command or notification instance with all struct fields set
   accordingly

This approach is used since it provides the caller with access to the additional fields in the request that are not part of the command such as the ID.

Unmarshalling a received Response object is also a two step process:

1) Unmarhsal the raw bytes into a Response struct instance via json.Unmarshal
2) Depending on the ID, unmarshal the Result field of the unmarshalled
   Response to create a concrete type instance

As above, this approach is used since it provides the caller with access to the fields in the response such as the ID and Error.

Command Creation

This package provides two approaches for creating a new command. This first, and preferred, method is to use one of the New<Foo>Cmd functions. This allows static compile-time checking to help ensure the parameters stay in sync with the struct definitions.

The second approach is the NewCmd function which takes a method (command) name and variable arguments. The function includes full checking to ensure the parameters are accurate according to provided method, however these checks are, obviously, run-time which means any mistakes won't be found until the code is actually executed. However, it is quite useful for user-supplied commands that are intentionally dynamic.

Custom Command Registration

The command handling of this package is built around the concept of registered commands. This is true for the wide variety of commands already provided by the package, but it also means caller can easily provide custom commands with all of the same functionality as the built-in commands. Use the RegisterCmd function for this purpose.

A list of all registered methods can be obtained with the RegisteredCmdMethods function.

Command Inspection

All registered commands are registered with flags that identify information such as whether the command applies to a chain server, wallet server, or is a notification along with the method name to use. These flags can be obtained with the MethodUsageFlags flags, and the method can be obtained with the CmdMethod function.

Help Generation

To facilitate providing consistent help to users of the RPC server, this package exposes the GenerateHelp and function which uses reflection on registered commands or notifications, as well as the provided expected result types, to generate the final help text.

In addition, the MethodUsageText function is provided to generate consistent one-line usage for registered commands and notifications using reflection.

Errors

There are 2 distinct type of errors supported by this package:

- General errors related to marshalling or unmarshalling or improper use of
  the package (type Error)
- RPC errors which are intended to be returned across the wire as a part of
  the JSON-RPC response (type RPCError)

The first category of errors (type Error) typically indicates a programmer error and can be avoided by properly using the API. Errors of this type will be returned from the various functions available in this package. They identify issues such as unsupported field types, attempts to register malformed commands, and attempting to create a new command with an improper number of parameters. The specific reason for the error can be detected by type asserting it to a *btcjson.Error and accessing the ErrorCode field.

The second category of errors (type RPCError), on the other hand, are useful for returning errors to RPC clients. Consequently, they are used in the previously described Response type.

Example (UnmarshalResponse)

    This example demonstrates how to unmarshal a JSON-RPC response and then unmarshal the result field in the response to a concrete type.

    Output:
    
    Block height: 350001
    

    Index

    Examples

    Constants

    View Source
    const (
    	// BlockConnectedNtfnMethod is the legacy, deprecated method used for
    	// notifications from the chain server that a block has been connected.
    	//
    	// Deprecated: Use FilteredBlockConnectedNtfnMethod instead.
    	BlockConnectedNtfnMethod = "blockconnected"
    
    	// BlockDisconnectedNtfnMethod is the legacy, deprecated method used for
    	// notifications from the chain server that a block has been
    	// disconnected.
    	//
    	// Deprecated: Use FilteredBlockDisconnectedNtfnMethod instead.
    	BlockDisconnectedNtfnMethod = "blockdisconnected"
    
    	// FilteredBlockConnectedNtfnMethod is the new method used for
    	// notifications from the chain server that a block has been connected.
    	FilteredBlockConnectedNtfnMethod = "filteredblockconnected"
    
    	// FilteredBlockDisconnectedNtfnMethod is the new method used for
    	// notifications from the chain server that a block has been
    	// disconnected.
    	FilteredBlockDisconnectedNtfnMethod = "filteredblockdisconnected"
    
    	// RecvTxNtfnMethod is the legacy, deprecated method used for
    	// notifications from the chain server that a transaction which pays to
    	// a registered address has been processed.
    	//
    	// Deprecated: Use RelevantTxAcceptedNtfnMethod and
    	// FilteredBlockConnectedNtfnMethod instead.
    	RecvTxNtfnMethod = "recvtx"
    
    	// RedeemingTxNtfnMethod is the legacy, deprecated method used for
    	// notifications from the chain server that a transaction which spends a
    	// registered outpoint has been processed.
    	//
    	// Deprecated: Use RelevantTxAcceptedNtfnMethod and
    	// FilteredBlockConnectedNtfnMethod instead.
    	RedeemingTxNtfnMethod = "redeemingtx"
    
    	// RescanFinishedNtfnMethod is the legacy, deprecated method used for
    	// notifications from the chain server that a legacy, deprecated rescan
    	// operation has finished.
    	//
    	// Deprecated: Not used with rescanblocks command.
    	RescanFinishedNtfnMethod = "rescanfinished"
    
    	// RescanProgressNtfnMethod is the legacy, deprecated method used for
    	// notifications from the chain server that a legacy, deprecated rescan
    	// operation this is underway has made progress.
    	//
    	// Deprecated: Not used with rescanblocks command.
    	RescanProgressNtfnMethod = "rescanprogress"
    
    	// TxAcceptedNtfnMethod is the method used for notifications from the
    	// chain server that a transaction has been accepted into the mempool.
    	TxAcceptedNtfnMethod = "txaccepted"
    
    	// TxAcceptedVerboseNtfnMethod is the method used for notifications from
    	// the chain server that a transaction has been accepted into the
    	// mempool.  This differs from TxAcceptedNtfnMethod in that it provides
    	// more details in the notification.
    	TxAcceptedVerboseNtfnMethod = "txacceptedverbose"
    
    	// RelevantTxAcceptedNtfnMethod is the new method used for notifications
    	// from the chain server that inform a client that a transaction that
    	// matches the loaded filter was accepted by the mempool.
    	RelevantTxAcceptedNtfnMethod = "relevanttxaccepted"
    )
    View Source
    const (
    	// AccountBalanceNtfnMethod is the method used for account balance
    	// notifications.
    	AccountBalanceNtfnMethod = "accountbalance"
    
    	// BtcdConnectedNtfnMethod is the method used for notifications when
    	// a wallet server is connected to a chain server.
    	BtcdConnectedNtfnMethod = "btcdconnected"
    
    	// WalletLockStateNtfnMethod is the method used to notify the lock state
    	// of a wallet has changed.
    	WalletLockStateNtfnMethod = "walletlockstate"
    
    	// NewTxNtfnMethod is the method used to notify that a wallet server has
    	// added a new transaction to the transaction store.
    	NewTxNtfnMethod = "newtx"
    )

    Variables

    View Source
    var (
    	ErrRPCInvalidRequest = &RPCError{
    		Code:    -32600,
    		Message: "Invalid request",
    	}
    	ErrRPCMethodNotFound = &RPCError{
    		Code:    -32601,
    		Message: "Method not found",
    	}
    	ErrRPCInvalidParams = &RPCError{
    		Code:    -32602,
    		Message: "Invalid parameters",
    	}
    	ErrRPCInternal = &RPCError{
    		Code:    -32603,
    		Message: "Internal error",
    	}
    	ErrRPCParse = &RPCError{
    		Code:    -32700,
    		Message: "Parse error",
    	}
    )

      Standard JSON-RPC 2.0 errors.

      Functions

      func Bool

      func Bool(v bool) *bool

        Bool is a helper routine that allocates a new bool value to store v and returns a pointer to it. This is useful when assigning optional parameters.

        func CmdMethod

        func CmdMethod(cmd interface{}) (string, error)

          CmdMethod returns the method for the passed command. The provided command type must be a registered type. All commands provided by this package are registered by default.

          func Float64

          func Float64(v float64) *float64

            Float64 is a helper routine that allocates a new float64 value to store v and returns a pointer to it. This is useful when assigning optional parameters.

            func GenerateHelp

            func GenerateHelp(method string, descs map[string]string, resultTypes ...interface{}) (string, error)

              GenerateHelp generates and returns help output for the provided method and result types given a map to provide the appropriate keys for the method synopsis, field descriptions, conditions, and result descriptions. The method must be associated with a registered type. All commands provided by this package are registered by default.

              The resultTypes must be pointer-to-types which represent the specific types of values the command returns. For example, if the command only returns a boolean value, there should only be a single entry of (*bool)(nil). Note that each type must be a single pointer to the type. Therefore, it is recommended to simply pass a nil pointer cast to the appropriate type as previously shown.

              The provided descriptions map must contain all of the keys or an error will be returned which includes the missing key, or the final missing key when there is more than one key missing. The generated help in the case of such an error will use the key in place of the description.

              The following outlines the required keys:

              "<method>--synopsis"             Synopsis for the command
              "<method>-<lowerfieldname>"      Description for each command argument
              "<typename>-<lowerfieldname>"    Description for each object field
              "<method>--condition<#>"         Description for each result condition
              "<method>--result<#>"            Description for each primitive result num
              

              Notice that the "special" keys synopsis, condition<#>, and result<#> are preceded by a double dash to ensure they don't conflict with field names.

              The condition keys are only required when there is more than on result type, and the result key for a given result type is only required if it's not an object.

              For example, consider the 'help' command itself. There are two possible returns depending on the provided parameters. So, the help would be generated by calling the function as follows:

              GenerateHelp("help", descs, (*string)(nil), (*string)(nil)).
              

              The following keys would then be required in the provided descriptions map:

              "help--synopsis":   "Returns a list of all commands or help for ...."
              "help-command":     "The command to retrieve help for",
              "help--condition0": "no command provided"
              "help--condition1": "command specified"
              "help--result0":    "List of commands"
              "help--result1":    "Help for specified command"
              

              func Int

              func Int(v int) *int

                Int is a helper routine that allocates a new int value to store v and returns a pointer to it. This is useful when assigning optional parameters.

                func Int32

                func Int32(v int32) *int32

                  Int32 is a helper routine that allocates a new int32 value to store v and returns a pointer to it. This is useful when assigning optional parameters.

                  func Int64

                  func Int64(v int64) *int64

                    Int64 is a helper routine that allocates a new int64 value to store v and returns a pointer to it. This is useful when assigning optional parameters.

                    func IsValidIDType

                    func IsValidIDType(id interface{}) bool

                      IsValidIDType checks that the ID field (which can go in any of the JSON-RPC requests, responses, or notifications) is valid. JSON-RPC 1.0 allows any valid JSON type. JSON-RPC 2.0 (which bitcoind follows for some parts) only allows string, number, or null, so this function restricts the allowed types to that list. This function is only provided in case the caller is manually marshalling for some reason. The functions which accept an ID in this package already call this function to ensure the provided id is valid.

                      func MarshalCmd

                      func MarshalCmd(rpcVersion string, id interface{}, cmd interface{}) ([]byte, error)

                        MarshalCmd marshals the passed command to a JSON-RPC request byte slice that is suitable for transmission to an RPC server. The provided command type must be a registered type. All commands provided by this package are registered by default.

                        Example

                          This example demonstrates how to create and marshal a command into a JSON-RPC request.

                          Output:
                          
                          {"jsonrpc":"1.0","method":"getblock","params":["000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",0],"id":1}
                          

                          func MarshalResponse

                          func MarshalResponse(rpcVersion string, id interface{}, result interface{}, rpcErr *RPCError) ([]byte, error)

                            MarshalResponse marshals the passed rpc version, id, result, and RPCError to a JSON-RPC response byte slice that is suitable for transmission to a JSON-RPC client.

                            Example

                              This example demonstrates how to marshal a JSON-RPC response.

                              Output:
                              
                              {"jsonrpc":"1.0","result":350001,"error":null,"id":1}
                              

                              func MethodUsageText

                              func MethodUsageText(method string) (string, error)

                                MethodUsageText returns a one-line usage string for the provided method. The provided method must be associated with a registered type. All commands provided by this package are registered by default.

                                func MustRegisterCmd

                                func MustRegisterCmd(method string, cmd interface{}, flags UsageFlag)

                                  MustRegisterCmd performs the same function as RegisterCmd except it panics if there is an error. This should only be called from package init functions.

                                  func NewCmd

                                  func NewCmd(method string, args ...interface{}) (interface{}, error)

                                    NewCmd provides a generic mechanism to create a new command that can marshal to a JSON-RPC request while respecting the requirements of the provided method. The method must have been registered with the package already along with its type definition. All methods associated with the commands exported by this package are already registered by default.

                                    The arguments are most efficient when they are the exact same type as the underlying field in the command struct associated with the the method, however this function also will perform a variety of conversions to make it more flexible. This allows, for example, command line args which are strings to be passed unaltered. In particular, the following conversions are supported:

                                    - Conversion between any size signed or unsigned integer so long as the
                                      value does not overflow the destination type
                                    - Conversion between float32 and float64 so long as the value does not
                                      overflow the destination type
                                    - Conversion from string to boolean for everything strconv.ParseBool
                                      recognizes
                                    - Conversion from string to any size integer for everything
                                      strconv.ParseInt and strconv.ParseUint recognizes
                                    - Conversion from string to any size float for everything
                                      strconv.ParseFloat recognizes
                                    - Conversion from string to arrays, slices, structs, and maps by treating
                                      the string as marshalled JSON and calling json.Unmarshal into the
                                      destination field
                                    

                                    func RegisterCmd

                                    func RegisterCmd(method string, cmd interface{}, flags UsageFlag) error

                                      RegisterCmd registers a new command that will automatically marshal to and from JSON-RPC with full type checking and positional parameter support. It also accepts usage flags which identify the circumstances under which the command can be used.

                                      This package automatically registers all of the exported commands by default using this function, however it is also exported so callers can easily register custom types.

                                      The type format is very strict since it needs to be able to automatically marshal to and from JSON-RPC 1.0. The following enumerates the requirements:

                                      - The provided command must be a single pointer to a struct
                                      - All fields must be exported
                                      - The order of the positional parameters in the marshalled JSON will be in
                                        the same order as declared in the struct definition
                                      - Struct embedding is not supported
                                      - Struct fields may NOT be channels, functions, complex, or interface
                                      - A field in the provided struct with a pointer is treated as optional
                                      - Multiple indirections (i.e **int) are not supported
                                      - Once the first optional field (pointer) is encountered, the remaining
                                        fields must also be optional fields (pointers) as required by positional
                                        params
                                      - A field that has a 'jsonrpcdefault' struct tag must be an optional field
                                        (pointer)
                                      

                                      NOTE: This function only needs to be able to examine the structure of the passed struct, so it does not need to be an actual instance. Therefore, it is recommended to simply pass a nil pointer cast to the appropriate type. For example, (*FooCmd)(nil).

                                      func RegisteredCmdMethods

                                      func RegisteredCmdMethods() []string

                                        RegisteredCmdMethods returns a sorted list of methods for all registered commands.

                                        func String

                                        func String(v string) *string

                                          String is a helper routine that allocates a new string value to store v and returns a pointer to it. This is useful when assigning optional parameters.

                                          func Uint

                                          func Uint(v uint) *uint

                                            Uint is a helper routine that allocates a new uint value to store v and returns a pointer to it. This is useful when assigning optional parameters.

                                            func Uint32

                                            func Uint32(v uint32) *uint32

                                              Uint32 is a helper routine that allocates a new uint32 value to store v and returns a pointer to it. This is useful when assigning optional parameters.

                                              func Uint64

                                              func Uint64(v uint64) *uint64

                                                Uint64 is a helper routine that allocates a new uint64 value to store v and returns a pointer to it. This is useful when assigning optional parameters.

                                                func UnmarshalCmd

                                                func UnmarshalCmd(r *Request) (interface{}, error)

                                                  UnmarshalCmd unmarshals a JSON-RPC request into a suitable concrete command so long as the method type contained within the marshalled request is registered.

                                                  Example

                                                    This example demonstrates how to unmarshal a JSON-RPC request and then unmarshal the concrete request into a concrete command.

                                                    Output:
                                                    
                                                    Hash: 000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f
                                                    Verbosity: 0
                                                    

                                                    Types

                                                    type AccountBalanceNtfn

                                                    type AccountBalanceNtfn struct {
                                                    	Account   string
                                                    	Balance   float64 // In BTC
                                                    	Confirmed bool    // Whether Balance is confirmed or unconfirmed.
                                                    }

                                                      AccountBalanceNtfn defines the accountbalance JSON-RPC notification.

                                                      func NewAccountBalanceNtfn

                                                      func NewAccountBalanceNtfn(account string, balance float64, confirmed bool) *AccountBalanceNtfn

                                                        NewAccountBalanceNtfn returns a new instance which can be used to issue an accountbalance JSON-RPC notification.

                                                        type AddMultisigAddressCmd

                                                        type AddMultisigAddressCmd struct {
                                                        	NRequired int
                                                        	Keys      []string
                                                        	Account   *string
                                                        }

                                                          AddMultisigAddressCmd defines the addmutisigaddress JSON-RPC command.

                                                          func NewAddMultisigAddressCmd

                                                          func NewAddMultisigAddressCmd(nRequired int, keys []string, account *string) *AddMultisigAddressCmd

                                                            NewAddMultisigAddressCmd returns a new instance which can be used to issue a addmultisigaddress JSON-RPC command.

                                                            The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                            type AddMultisigAddressResult

                                                            type AddMultisigAddressResult struct {
                                                            	Address      string `json:"address"`
                                                            	RedeemScript string `json:"redeemScript"`
                                                            }

                                                              AddMultisigAddressResult models the data returned from the addmultisigaddress command.

                                                              type AddNodeCmd

                                                              type AddNodeCmd struct {
                                                              	Addr   string
                                                              	SubCmd AddNodeSubCmd `jsonrpcusage:"\"add|remove|onetry\""`
                                                              }

                                                                AddNodeCmd defines the addnode JSON-RPC command.

                                                                func NewAddNodeCmd

                                                                func NewAddNodeCmd(addr string, subCmd AddNodeSubCmd) *AddNodeCmd

                                                                  NewAddNodeCmd returns a new instance which can be used to issue an addnode JSON-RPC command.

                                                                  type AddNodeSubCmd

                                                                  type AddNodeSubCmd string

                                                                    AddNodeSubCmd defines the type used in the addnode JSON-RPC command for the sub command field.

                                                                    const (
                                                                    	// ANAdd indicates the specified host should be added as a persistent
                                                                    	// peer.
                                                                    	ANAdd AddNodeSubCmd = "add"
                                                                    
                                                                    	// ANRemove indicates the specified peer should be removed.
                                                                    	ANRemove AddNodeSubCmd = "remove"
                                                                    
                                                                    	// ANOneTry indicates the specified host should try to connect once,
                                                                    	// but it should not be made persistent.
                                                                    	ANOneTry AddNodeSubCmd = "onetry"
                                                                    )

                                                                    type AuthenticateCmd

                                                                    type AuthenticateCmd struct {
                                                                    	Username   string
                                                                    	Passphrase string
                                                                    }

                                                                      AuthenticateCmd defines the authenticate JSON-RPC command.

                                                                      func NewAuthenticateCmd

                                                                      func NewAuthenticateCmd(username, passphrase string) *AuthenticateCmd

                                                                        NewAuthenticateCmd returns a new instance which can be used to issue an authenticate JSON-RPC command.

                                                                        type BalanceDetailsResult

                                                                        type BalanceDetailsResult struct {
                                                                        	Trusted          float64  `json:"trusted"`
                                                                        	UntrustedPending float64  `json:"untrusted_pending"`
                                                                        	Immature         float64  `json:"immature"`
                                                                        	Used             *float64 `json:"used"`
                                                                        }

                                                                          BalanceDetailsResult models the details data from the `getbalances` command.

                                                                          type Bip9SoftForkDescription

                                                                          type Bip9SoftForkDescription struct {
                                                                          	Status    string `json:"status"`
                                                                          	Bit       uint8  `json:"bit"`
                                                                          	StartTime int64  `json:"startTime"`
                                                                          	Timeout   int64  `json:"timeout"`
                                                                          	Since     int32  `json:"since"`
                                                                          }

                                                                            Bip9SoftForkDescription describes the current state of a defined BIP0009 version bits soft-fork.

                                                                            type BlockConnectedNtfn

                                                                            type BlockConnectedNtfn struct {
                                                                            	Hash   string
                                                                            	Height int32
                                                                            	Time   int64
                                                                            }

                                                                              BlockConnectedNtfn defines the blockconnected JSON-RPC notification.

                                                                              Deprecated: Use FilteredBlockConnectedNtfn instead.

                                                                              func NewBlockConnectedNtfn

                                                                              func NewBlockConnectedNtfn(hash string, height int32, time int64) *BlockConnectedNtfn

                                                                                NewBlockConnectedNtfn returns a new instance which can be used to issue a blockconnected JSON-RPC notification.

                                                                                Deprecated: Use NewFilteredBlockConnectedNtfn instead.

                                                                                type BlockDetails

                                                                                type BlockDetails struct {
                                                                                	Height int32  `json:"height"`
                                                                                	Hash   string `json:"hash"`
                                                                                	Index  int    `json:"index"`
                                                                                	Time   int64  `json:"time"`
                                                                                }

                                                                                  BlockDetails describes details of a tx in a block.

                                                                                  type BlockDisconnectedNtfn

                                                                                  type BlockDisconnectedNtfn struct {
                                                                                  	Hash   string
                                                                                  	Height int32
                                                                                  	Time   int64
                                                                                  }

                                                                                    BlockDisconnectedNtfn defines the blockdisconnected JSON-RPC notification.

                                                                                    Deprecated: Use FilteredBlockDisconnectedNtfn instead.

                                                                                    func NewBlockDisconnectedNtfn

                                                                                    func NewBlockDisconnectedNtfn(hash string, height int32, time int64) *BlockDisconnectedNtfn

                                                                                      NewBlockDisconnectedNtfn returns a new instance which can be used to issue a blockdisconnected JSON-RPC notification.

                                                                                      Deprecated: Use NewFilteredBlockDisconnectedNtfn instead.

                                                                                      type BtcdConnectedNtfn

                                                                                      type BtcdConnectedNtfn struct {
                                                                                      	Connected bool
                                                                                      }

                                                                                        BtcdConnectedNtfn defines the btcdconnected JSON-RPC notification.

                                                                                        func NewBtcdConnectedNtfn

                                                                                        func NewBtcdConnectedNtfn(connected bool) *BtcdConnectedNtfn

                                                                                          NewBtcdConnectedNtfn returns a new instance which can be used to issue a btcdconnected JSON-RPC notification.

                                                                                          type CreateEncryptedWalletCmd

                                                                                          type CreateEncryptedWalletCmd struct {
                                                                                          	Passphrase string
                                                                                          }

                                                                                            CreateEncryptedWalletCmd defines the createencryptedwallet JSON-RPC command.

                                                                                            func NewCreateEncryptedWalletCmd

                                                                                            func NewCreateEncryptedWalletCmd(passphrase string) *CreateEncryptedWalletCmd

                                                                                              NewCreateEncryptedWalletCmd returns a new instance which can be used to issue a createencryptedwallet JSON-RPC command.

                                                                                              type CreateMultiSigResult

                                                                                              type CreateMultiSigResult struct {
                                                                                              	Address      string `json:"address"`
                                                                                              	RedeemScript string `json:"redeemScript"`
                                                                                              }

                                                                                                CreateMultiSigResult models the data returned from the createmultisig command.

                                                                                                type CreateMultisigCmd

                                                                                                type CreateMultisigCmd struct {
                                                                                                	NRequired int
                                                                                                	Keys      []string
                                                                                                }

                                                                                                  CreateMultisigCmd defines the createmultisig JSON-RPC command.

                                                                                                  func NewCreateMultisigCmd

                                                                                                  func NewCreateMultisigCmd(nRequired int, keys []string) *CreateMultisigCmd

                                                                                                    NewCreateMultisigCmd returns a new instance which can be used to issue a createmultisig JSON-RPC command.

                                                                                                    type CreateNewAccountCmd

                                                                                                    type CreateNewAccountCmd struct {
                                                                                                    	Account string
                                                                                                    }

                                                                                                      CreateNewAccountCmd defines the createnewaccount JSON-RPC command.

                                                                                                      func NewCreateNewAccountCmd

                                                                                                      func NewCreateNewAccountCmd(account string) *CreateNewAccountCmd

                                                                                                        NewCreateNewAccountCmd returns a new instance which can be used to issue a createnewaccount JSON-RPC command.

                                                                                                        type CreateRawTransactionCmd

                                                                                                        type CreateRawTransactionCmd struct {
                                                                                                        	Inputs   []TransactionInput
                                                                                                        	Amounts  map[string]float64 `jsonrpcusage:"{\"address\":amount,...}"` // In BTC
                                                                                                        	LockTime *int64
                                                                                                        }

                                                                                                          CreateRawTransactionCmd defines the createrawtransaction JSON-RPC command.

                                                                                                          func NewCreateRawTransactionCmd

                                                                                                          func NewCreateRawTransactionCmd(inputs []TransactionInput, amounts map[string]float64,
                                                                                                          	lockTime *int64) *CreateRawTransactionCmd

                                                                                                            NewCreateRawTransactionCmd returns a new instance which can be used to issue a createrawtransaction JSON-RPC command.

                                                                                                            Amounts are in BTC.

                                                                                                            type DebugLevelCmd

                                                                                                            type DebugLevelCmd struct {
                                                                                                            	LevelSpec string
                                                                                                            }

                                                                                                              DebugLevelCmd defines the debuglevel JSON-RPC command. This command is not a standard Bitcoin command. It is an extension for btcd.

                                                                                                              func NewDebugLevelCmd

                                                                                                              func NewDebugLevelCmd(levelSpec string) *DebugLevelCmd

                                                                                                                NewDebugLevelCmd returns a new DebugLevelCmd which can be used to issue a debuglevel JSON-RPC command. This command is not a standard Bitcoin command. It is an extension for btcd.

                                                                                                                type DecodeRawTransactionCmd

                                                                                                                type DecodeRawTransactionCmd struct {
                                                                                                                	HexTx string
                                                                                                                }

                                                                                                                  DecodeRawTransactionCmd defines the decoderawtransaction JSON-RPC command.

                                                                                                                  func NewDecodeRawTransactionCmd

                                                                                                                  func NewDecodeRawTransactionCmd(hexTx string) *DecodeRawTransactionCmd

                                                                                                                    NewDecodeRawTransactionCmd returns a new instance which can be used to issue a decoderawtransaction JSON-RPC command.

                                                                                                                    type DecodeScriptCmd

                                                                                                                    type DecodeScriptCmd struct {
                                                                                                                    	HexScript string
                                                                                                                    }

                                                                                                                      DecodeScriptCmd defines the decodescript JSON-RPC command.

                                                                                                                      func NewDecodeScriptCmd

                                                                                                                      func NewDecodeScriptCmd(hexScript string) *DecodeScriptCmd

                                                                                                                        NewDecodeScriptCmd returns a new instance which can be used to issue a decodescript JSON-RPC command.

                                                                                                                        type DecodeScriptResult

                                                                                                                        type DecodeScriptResult struct {
                                                                                                                        	Asm       string   `json:"asm"`
                                                                                                                        	ReqSigs   int32    `json:"reqSigs,omitempty"`
                                                                                                                        	Type      string   `json:"type"`
                                                                                                                        	Addresses []string `json:"addresses,omitempty"`
                                                                                                                        	P2sh      string   `json:"p2sh,omitempty"`
                                                                                                                        }

                                                                                                                          DecodeScriptResult models the data returned from the decodescript command.

                                                                                                                          type DumpPrivKeyCmd

                                                                                                                          type DumpPrivKeyCmd struct {
                                                                                                                          	Address string
                                                                                                                          }

                                                                                                                            DumpPrivKeyCmd defines the dumpprivkey JSON-RPC command.

                                                                                                                            func NewDumpPrivKeyCmd

                                                                                                                            func NewDumpPrivKeyCmd(address string) *DumpPrivKeyCmd

                                                                                                                              NewDumpPrivKeyCmd returns a new instance which can be used to issue a dumpprivkey JSON-RPC command.

                                                                                                                              type DumpWalletCmd

                                                                                                                              type DumpWalletCmd struct {
                                                                                                                              	Filename string
                                                                                                                              }

                                                                                                                                DumpWalletCmd defines the dumpwallet JSON-RPC command.

                                                                                                                                func NewDumpWalletCmd

                                                                                                                                func NewDumpWalletCmd(filename string) *DumpWalletCmd

                                                                                                                                  NewDumpWalletCmd returns a new instance which can be used to issue a dumpwallet JSON-RPC command.

                                                                                                                                  type EncryptWalletCmd

                                                                                                                                  type EncryptWalletCmd struct {
                                                                                                                                  	Passphrase string
                                                                                                                                  }

                                                                                                                                    EncryptWalletCmd defines the encryptwallet JSON-RPC command.

                                                                                                                                    func NewEncryptWalletCmd

                                                                                                                                    func NewEncryptWalletCmd(passphrase string) *EncryptWalletCmd

                                                                                                                                      NewEncryptWalletCmd returns a new instance which can be used to issue a encryptwallet JSON-RPC command.

                                                                                                                                      type Error

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

                                                                                                                                        Error identifies a general error. This differs from an RPCError in that this error typically is used more by the consumers of the package as opposed to RPCErrors which are intended to be returned to the client across the wire via a JSON-RPC Response. The caller can use type assertions to determine the specific error and access the ErrorCode field.

                                                                                                                                        func (Error) Error

                                                                                                                                        func (e Error) Error() string

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

                                                                                                                                          type ErrorCode

                                                                                                                                          type ErrorCode int

                                                                                                                                            ErrorCode identifies a kind of error. These error codes are NOT used for JSON-RPC response errors.

                                                                                                                                            const (
                                                                                                                                            	// ErrDuplicateMethod indicates a command with the specified method
                                                                                                                                            	// already exists.
                                                                                                                                            	ErrDuplicateMethod ErrorCode = iota
                                                                                                                                            
                                                                                                                                            	// ErrInvalidUsageFlags indicates one or more unrecognized flag bits
                                                                                                                                            	// were specified.
                                                                                                                                            	ErrInvalidUsageFlags
                                                                                                                                            
                                                                                                                                            	// ErrInvalidType indicates a type was passed that is not the required
                                                                                                                                            	// type.
                                                                                                                                            	ErrInvalidType
                                                                                                                                            
                                                                                                                                            	// ErrEmbeddedType indicates the provided command struct contains an
                                                                                                                                            	// embedded type which is not not supported.
                                                                                                                                            	ErrEmbeddedType
                                                                                                                                            
                                                                                                                                            	// ErrUnexportedField indiciates the provided command struct contains an
                                                                                                                                            	// unexported field which is not supported.
                                                                                                                                            	ErrUnexportedField
                                                                                                                                            
                                                                                                                                            	// ErrUnsupportedFieldType indicates the type of a field in the provided
                                                                                                                                            	// command struct is not one of the supported types.
                                                                                                                                            	ErrUnsupportedFieldType
                                                                                                                                            
                                                                                                                                            	// ErrNonOptionalField indicates a non-optional field was specified
                                                                                                                                            	// after an optional field.
                                                                                                                                            	ErrNonOptionalField
                                                                                                                                            
                                                                                                                                            	// ErrNonOptionalDefault indicates a 'jsonrpcdefault' struct tag was
                                                                                                                                            	// specified for a non-optional field.
                                                                                                                                            	ErrNonOptionalDefault
                                                                                                                                            
                                                                                                                                            	// ErrMismatchedDefault indicates a 'jsonrpcdefault' struct tag contains
                                                                                                                                            	// a value that doesn't match the type of the field.
                                                                                                                                            	ErrMismatchedDefault
                                                                                                                                            
                                                                                                                                            	// ErrUnregisteredMethod indicates a method was specified that has not
                                                                                                                                            	// been registered.
                                                                                                                                            	ErrUnregisteredMethod
                                                                                                                                            
                                                                                                                                            	// ErrMissingDescription indicates a description required to generate
                                                                                                                                            	// help is missing.
                                                                                                                                            	ErrMissingDescription
                                                                                                                                            
                                                                                                                                            	// ErrNumParams inidcates the number of params supplied do not
                                                                                                                                            	// match the requirements of the associated command.
                                                                                                                                            	ErrNumParams
                                                                                                                                            )

                                                                                                                                              These constants are used to identify a specific RuleError.

                                                                                                                                              func (ErrorCode) String

                                                                                                                                              func (e ErrorCode) String() string

                                                                                                                                                String returns the ErrorCode as a human-readable name.

                                                                                                                                                type EstimateFeeCmd

                                                                                                                                                type EstimateFeeCmd struct {
                                                                                                                                                	NumBlocks int64
                                                                                                                                                }

                                                                                                                                                  EstimateFeeCmd defines the estimatefee JSON-RPC command.

                                                                                                                                                  func NewEstimateFeeCmd

                                                                                                                                                  func NewEstimateFeeCmd(numBlocks int64) *EstimateFeeCmd

                                                                                                                                                    NewEstimateFeeCmd returns a new instance which can be used to issue a estimatefee JSON-RPC command.

                                                                                                                                                    type EstimatePriorityCmd

                                                                                                                                                    type EstimatePriorityCmd struct {
                                                                                                                                                    	NumBlocks int64
                                                                                                                                                    }

                                                                                                                                                      EstimatePriorityCmd defines the estimatepriority JSON-RPC command.

                                                                                                                                                      func NewEstimatePriorityCmd

                                                                                                                                                      func NewEstimatePriorityCmd(numBlocks int64) *EstimatePriorityCmd

                                                                                                                                                        NewEstimatePriorityCmd returns a new instance which can be used to issue a estimatepriority JSON-RPC command.

                                                                                                                                                        type ExportWatchingWalletCmd

                                                                                                                                                        type ExportWatchingWalletCmd struct {
                                                                                                                                                        	Account  *string
                                                                                                                                                        	Download *bool `jsonrpcdefault:"false"`
                                                                                                                                                        }

                                                                                                                                                          ExportWatchingWalletCmd defines the exportwatchingwallet JSON-RPC command.

                                                                                                                                                          func NewExportWatchingWalletCmd

                                                                                                                                                          func NewExportWatchingWalletCmd(account *string, download *bool) *ExportWatchingWalletCmd

                                                                                                                                                            NewExportWatchingWalletCmd returns a new instance which can be used to issue a exportwatchingwallet JSON-RPC command.

                                                                                                                                                            The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                            type FilteredBlockConnectedNtfn

                                                                                                                                                            type FilteredBlockConnectedNtfn struct {
                                                                                                                                                            	Height        int32
                                                                                                                                                            	Header        string
                                                                                                                                                            	SubscribedTxs []string
                                                                                                                                                            }

                                                                                                                                                              FilteredBlockConnectedNtfn defines the filteredblockconnected JSON-RPC notification.

                                                                                                                                                              func NewFilteredBlockConnectedNtfn

                                                                                                                                                              func NewFilteredBlockConnectedNtfn(height int32, header string, subscribedTxs []string) *FilteredBlockConnectedNtfn

                                                                                                                                                                NewFilteredBlockConnectedNtfn returns a new instance which can be used to issue a filteredblockconnected JSON-RPC notification.

                                                                                                                                                                type FilteredBlockDisconnectedNtfn

                                                                                                                                                                type FilteredBlockDisconnectedNtfn struct {
                                                                                                                                                                	Height int32
                                                                                                                                                                	Header string
                                                                                                                                                                }

                                                                                                                                                                  FilteredBlockDisconnectedNtfn defines the filteredblockdisconnected JSON-RPC notification.

                                                                                                                                                                  func NewFilteredBlockDisconnectedNtfn

                                                                                                                                                                  func NewFilteredBlockDisconnectedNtfn(height int32, header string) *FilteredBlockDisconnectedNtfn

                                                                                                                                                                    NewFilteredBlockDisconnectedNtfn returns a new instance which can be used to issue a filteredblockdisconnected JSON-RPC notification.

                                                                                                                                                                    type GenerateCmd

                                                                                                                                                                    type GenerateCmd struct {
                                                                                                                                                                    	NumBlocks uint32
                                                                                                                                                                    }

                                                                                                                                                                      GenerateCmd defines the generate JSON-RPC command.

                                                                                                                                                                      func NewGenerateCmd

                                                                                                                                                                      func NewGenerateCmd(numBlocks uint32) *GenerateCmd

                                                                                                                                                                        NewGenerateCmd returns a new instance which can be used to issue a generate JSON-RPC command.

                                                                                                                                                                        type GetAccountAddressCmd

                                                                                                                                                                        type GetAccountAddressCmd struct {
                                                                                                                                                                        	Account string
                                                                                                                                                                        }

                                                                                                                                                                          GetAccountAddressCmd defines the getaccountaddress JSON-RPC command.

                                                                                                                                                                          func NewGetAccountAddressCmd

                                                                                                                                                                          func NewGetAccountAddressCmd(account string) *GetAccountAddressCmd

                                                                                                                                                                            NewGetAccountAddressCmd returns a new instance which can be used to issue a getaccountaddress JSON-RPC command.

                                                                                                                                                                            type GetAccountCmd

                                                                                                                                                                            type GetAccountCmd struct {
                                                                                                                                                                            	Address string
                                                                                                                                                                            }

                                                                                                                                                                              GetAccountCmd defines the getaccount JSON-RPC command.

                                                                                                                                                                              func NewGetAccountCmd

                                                                                                                                                                              func NewGetAccountCmd(address string) *GetAccountCmd

                                                                                                                                                                                NewGetAccountCmd returns a new instance which can be used to issue a getaccount JSON-RPC command.

                                                                                                                                                                                type GetAddedNodeInfoCmd

                                                                                                                                                                                type GetAddedNodeInfoCmd struct {
                                                                                                                                                                                	DNS  bool
                                                                                                                                                                                	Node *string
                                                                                                                                                                                }

                                                                                                                                                                                  GetAddedNodeInfoCmd defines the getaddednodeinfo JSON-RPC command.

                                                                                                                                                                                  func NewGetAddedNodeInfoCmd

                                                                                                                                                                                  func NewGetAddedNodeInfoCmd(dns bool, node *string) *GetAddedNodeInfoCmd

                                                                                                                                                                                    NewGetAddedNodeInfoCmd returns a new instance which can be used to issue a getaddednodeinfo JSON-RPC command.

                                                                                                                                                                                    The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                    type GetAddedNodeInfoResult

                                                                                                                                                                                    type GetAddedNodeInfoResult struct {
                                                                                                                                                                                    	AddedNode string                        `json:"addednode"`
                                                                                                                                                                                    	Connected *bool                         `json:"connected,omitempty"`
                                                                                                                                                                                    	Addresses *[]GetAddedNodeInfoResultAddr `json:"addresses,omitempty"`
                                                                                                                                                                                    }

                                                                                                                                                                                      GetAddedNodeInfoResult models the data from the getaddednodeinfo command.

                                                                                                                                                                                      type GetAddedNodeInfoResultAddr

                                                                                                                                                                                      type GetAddedNodeInfoResultAddr struct {
                                                                                                                                                                                      	Address   string `json:"address"`
                                                                                                                                                                                      	Connected string `json:"connected"`
                                                                                                                                                                                      }

                                                                                                                                                                                        GetAddedNodeInfoResultAddr models the data of the addresses portion of the getaddednodeinfo command.

                                                                                                                                                                                        type GetAddressesByAccountCmd

                                                                                                                                                                                        type GetAddressesByAccountCmd struct {
                                                                                                                                                                                        	Account string
                                                                                                                                                                                        }

                                                                                                                                                                                          GetAddressesByAccountCmd defines the getaddressesbyaccount JSON-RPC command.

                                                                                                                                                                                          func NewGetAddressesByAccountCmd

                                                                                                                                                                                          func NewGetAddressesByAccountCmd(account string) *GetAddressesByAccountCmd

                                                                                                                                                                                            NewGetAddressesByAccountCmd returns a new instance which can be used to issue a getaddressesbyaccount JSON-RPC command.

                                                                                                                                                                                            type GetBalanceCmd

                                                                                                                                                                                            type GetBalanceCmd struct {
                                                                                                                                                                                            	Account *string
                                                                                                                                                                                            	MinConf *int `jsonrpcdefault:"1"`
                                                                                                                                                                                            }

                                                                                                                                                                                              GetBalanceCmd defines the getbalance JSON-RPC command.

                                                                                                                                                                                              func NewGetBalanceCmd

                                                                                                                                                                                              func NewGetBalanceCmd(account *string, minConf *int) *GetBalanceCmd

                                                                                                                                                                                                NewGetBalanceCmd returns a new instance which can be used to issue a getbalance JSON-RPC command.

                                                                                                                                                                                                The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                type GetBalancesCmd

                                                                                                                                                                                                type GetBalancesCmd struct{}

                                                                                                                                                                                                  GetBalancesCmd defines the getbalances JSON-RPC command.

                                                                                                                                                                                                  func NewGetBalancesCmd

                                                                                                                                                                                                  func NewGetBalancesCmd() *GetBalancesCmd

                                                                                                                                                                                                    NewGetBalancesCmd returns a new instance which can be used to issue a getbalances JSON-RPC command.

                                                                                                                                                                                                    type GetBalancesResult

                                                                                                                                                                                                    type GetBalancesResult struct {
                                                                                                                                                                                                    	Mine      BalanceDetailsResult  `json:"mine"`
                                                                                                                                                                                                    	WatchOnly *BalanceDetailsResult `json:"watchonly"`
                                                                                                                                                                                                    }

                                                                                                                                                                                                      GetBalancesResult models the data returned from the getbalances command.

                                                                                                                                                                                                      type GetBestBlockCmd

                                                                                                                                                                                                      type GetBestBlockCmd struct{}

                                                                                                                                                                                                        GetBestBlockCmd defines the getbestblock JSON-RPC command.

                                                                                                                                                                                                        func NewGetBestBlockCmd

                                                                                                                                                                                                        func NewGetBestBlockCmd() *GetBestBlockCmd

                                                                                                                                                                                                          NewGetBestBlockCmd returns a new instance which can be used to issue a getbestblock JSON-RPC command.

                                                                                                                                                                                                          type GetBestBlockHashCmd

                                                                                                                                                                                                          type GetBestBlockHashCmd struct{}

                                                                                                                                                                                                            GetBestBlockHashCmd defines the getbestblockhash JSON-RPC command.

                                                                                                                                                                                                            func NewGetBestBlockHashCmd

                                                                                                                                                                                                            func NewGetBestBlockHashCmd() *GetBestBlockHashCmd

                                                                                                                                                                                                              NewGetBestBlockHashCmd returns a new instance which can be used to issue a getbestblockhash JSON-RPC command.

                                                                                                                                                                                                              type GetBestBlockResult

                                                                                                                                                                                                              type GetBestBlockResult struct {
                                                                                                                                                                                                              	Hash   string `json:"hash"`
                                                                                                                                                                                                              	Height int32  `json:"height"`
                                                                                                                                                                                                              }

                                                                                                                                                                                                                GetBestBlockResult models the data from the getbestblock command.

                                                                                                                                                                                                                type GetBlockChainInfoCmd

                                                                                                                                                                                                                type GetBlockChainInfoCmd struct{}

                                                                                                                                                                                                                  GetBlockChainInfoCmd defines the getblockchaininfo JSON-RPC command.

                                                                                                                                                                                                                  func NewGetBlockChainInfoCmd

                                                                                                                                                                                                                  func NewGetBlockChainInfoCmd() *GetBlockChainInfoCmd

                                                                                                                                                                                                                    NewGetBlockChainInfoCmd returns a new instance which can be used to issue a getblockchaininfo JSON-RPC command.

                                                                                                                                                                                                                    type GetBlockChainInfoResult

                                                                                                                                                                                                                    type GetBlockChainInfoResult struct {
                                                                                                                                                                                                                    	Chain                string                              `json:"chain"`
                                                                                                                                                                                                                    	Blocks               int32                               `json:"blocks"`
                                                                                                                                                                                                                    	Headers              int32                               `json:"headers"`
                                                                                                                                                                                                                    	BestBlockHash        string                              `json:"bestblockhash"`
                                                                                                                                                                                                                    	Difficulty           float64                             `json:"difficulty"`
                                                                                                                                                                                                                    	MedianTime           int64                               `json:"mediantime"`
                                                                                                                                                                                                                    	VerificationProgress float64                             `json:"verificationprogress,omitempty"`
                                                                                                                                                                                                                    	SyncHeight           uint64                              `json:"syncheight,omitempty"`
                                                                                                                                                                                                                    	Pruned               bool                                `json:"pruned"`
                                                                                                                                                                                                                    	PruneHeight          int32                               `json:"pruneheight,omitempty"`
                                                                                                                                                                                                                    	ChainWork            string                              `json:"chainwork,omitempty"`
                                                                                                                                                                                                                    	SoftForks            []*SoftForkDescription              `json:"softforks"`
                                                                                                                                                                                                                    	Bip9SoftForks        map[string]*Bip9SoftForkDescription `json:"bip9_softforks"`
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      GetBlockChainInfoResult models the data returned from the getblockchaininfo command.

                                                                                                                                                                                                                      type GetBlockCmd

                                                                                                                                                                                                                      type GetBlockCmd struct {
                                                                                                                                                                                                                      	Hash      string
                                                                                                                                                                                                                      	Verbosity *VerbosityLevel `jsonrpcdefault:"1"`
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        GetBlockCmd defines the getblock JSON-RPC command.

                                                                                                                                                                                                                        func NewGetBlockCmd

                                                                                                                                                                                                                        func NewGetBlockCmd(hash string, verbosity *VerbosityLevel) *GetBlockCmd

                                                                                                                                                                                                                          NewGetBlockCmd returns a new instance which can be used to issue a getblock JSON-RPC command.

                                                                                                                                                                                                                          The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                          type GetBlockCountCmd

                                                                                                                                                                                                                          type GetBlockCountCmd struct{}

                                                                                                                                                                                                                            GetBlockCountCmd defines the getblockcount JSON-RPC command.

                                                                                                                                                                                                                            func NewGetBlockCountCmd

                                                                                                                                                                                                                            func NewGetBlockCountCmd() *GetBlockCountCmd

                                                                                                                                                                                                                              NewGetBlockCountCmd returns a new instance which can be used to issue a getblockcount JSON-RPC command.

                                                                                                                                                                                                                              type GetBlockHashCmd

                                                                                                                                                                                                                              type GetBlockHashCmd struct {
                                                                                                                                                                                                                              	Index int64
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                GetBlockHashCmd defines the getblockhash JSON-RPC command.

                                                                                                                                                                                                                                func NewGetBlockHashCmd

                                                                                                                                                                                                                                func NewGetBlockHashCmd(index int64) *GetBlockHashCmd

                                                                                                                                                                                                                                  NewGetBlockHashCmd returns a new instance which can be used to issue a getblockhash JSON-RPC command.

                                                                                                                                                                                                                                  type GetBlockHeaderCmd

                                                                                                                                                                                                                                  type GetBlockHeaderCmd struct {
                                                                                                                                                                                                                                  	Hash    string
                                                                                                                                                                                                                                  	Verbose *bool `jsonrpcdefault:"true"`
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    GetBlockHeaderCmd defines the getblockheader JSON-RPC command.

                                                                                                                                                                                                                                    func NewGetBlockHeaderCmd

                                                                                                                                                                                                                                    func NewGetBlockHeaderCmd(hash string, verbose *bool) *GetBlockHeaderCmd

                                                                                                                                                                                                                                      NewGetBlockHeaderCmd returns a new instance which can be used to issue a getblockheader JSON-RPC command.

                                                                                                                                                                                                                                      type GetBlockHeaderVerboseResult

                                                                                                                                                                                                                                      type GetBlockHeaderVerboseResult struct {
                                                                                                                                                                                                                                      	Hash          string  `json:"hash"`
                                                                                                                                                                                                                                      	Confirmations int64   `json:"confirmations"`
                                                                                                                                                                                                                                      	Height        int32   `json:"height"`
                                                                                                                                                                                                                                      	Version       int32   `json:"version"`
                                                                                                                                                                                                                                      	VersionHex    string  `json:"versionHex"`
                                                                                                                                                                                                                                      	MerkleRoot    string  `json:"merkleroot"`
                                                                                                                                                                                                                                      	Time          int64   `json:"time"`
                                                                                                                                                                                                                                      	Nonce         uint64  `json:"nonce"`
                                                                                                                                                                                                                                      	Bits          string  `json:"bits"`
                                                                                                                                                                                                                                      	Difficulty    float64 `json:"difficulty"`
                                                                                                                                                                                                                                      	PreviousHash  string  `json:"previousblockhash,omitempty"`
                                                                                                                                                                                                                                      	NextHash      string  `json:"nextblockhash,omitempty"`
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        GetBlockHeaderVerboseResult models the data from the getblockheader command when the verbose flag is set. When the verbose flag is not set, getblockheader returns a hex-encoded string.

                                                                                                                                                                                                                                        type GetBlockTemplateCmd

                                                                                                                                                                                                                                        type GetBlockTemplateCmd struct {
                                                                                                                                                                                                                                        	Request *TemplateRequest
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          GetBlockTemplateCmd defines the getblocktemplate JSON-RPC command.

                                                                                                                                                                                                                                          func NewGetBlockTemplateCmd

                                                                                                                                                                                                                                          func NewGetBlockTemplateCmd(request *TemplateRequest) *GetBlockTemplateCmd

                                                                                                                                                                                                                                            NewGetBlockTemplateCmd returns a new instance which can be used to issue a getblocktemplate JSON-RPC command.

                                                                                                                                                                                                                                            The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                            type GetBlockTemplateResult

                                                                                                                                                                                                                                            type GetBlockTemplateResult struct {
                                                                                                                                                                                                                                            	// Base fields from BIP 0022.  CoinbaseAux is optional.  One of
                                                                                                                                                                                                                                            	// CoinbaseTxn or CoinbaseValue must be specified, but not both.
                                                                                                                                                                                                                                            	Bits          string                     `json:"bits"`
                                                                                                                                                                                                                                            	CurTime       int64                      `json:"curtime"`
                                                                                                                                                                                                                                            	Height        int64                      `json:"height"`
                                                                                                                                                                                                                                            	PreviousHash  string                     `json:"previousblockhash"`
                                                                                                                                                                                                                                            	SizeLimit     int64                      `json:"sizelimit,omitempty"`
                                                                                                                                                                                                                                            	SigCheckLimit int64                      `json:"sigchecklimit,omitempty"`
                                                                                                                                                                                                                                            	SigCheckTotal int64                      `json:"sigchecktotal,omitempty"`
                                                                                                                                                                                                                                            	Transactions  []GetBlockTemplateResultTx `json:"transactions"`
                                                                                                                                                                                                                                            	Version       int32                      `json:"version"`
                                                                                                                                                                                                                                            	CoinbaseAux   *GetBlockTemplateResultAux `json:"coinbaseaux,omitempty"`
                                                                                                                                                                                                                                            	CoinbaseTxn   *GetBlockTemplateResultTx  `json:"coinbasetxn,omitempty"`
                                                                                                                                                                                                                                            	CoinbaseValue *int64                     `json:"coinbasevalue,omitempty"`
                                                                                                                                                                                                                                            	WorkID        string                     `json:"workid,omitempty"`
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// Optional long polling from BIP 0022.
                                                                                                                                                                                                                                            	LongPollID  string `json:"longpollid,omitempty"`
                                                                                                                                                                                                                                            	LongPollURI string `json:"longpolluri,omitempty"`
                                                                                                                                                                                                                                            	SubmitOld   *bool  `json:"submitold,omitempty"`
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// Basic pool extension from BIP 0023.
                                                                                                                                                                                                                                            	Target  string `json:"target,omitempty"`
                                                                                                                                                                                                                                            	Expires int64  `json:"expires,omitempty"`
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// Mutations from BIP 0023.
                                                                                                                                                                                                                                            	MaxTime    int64    `json:"maxtime,omitempty"`
                                                                                                                                                                                                                                            	MinTime    int64    `json:"mintime,omitempty"`
                                                                                                                                                                                                                                            	Mutable    []string `json:"mutable,omitempty"`
                                                                                                                                                                                                                                            	NonceRange string   `json:"noncerange,omitempty"`
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	// Block proposal from BIP 0023.
                                                                                                                                                                                                                                            	Capabilities  []string `json:"capabilities,omitempty"`
                                                                                                                                                                                                                                            	RejectReasion string   `json:"reject-reason,omitempty"`
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                              GetBlockTemplateResult models the data returned from the getblocktemplate command.

                                                                                                                                                                                                                                              type GetBlockTemplateResultAux

                                                                                                                                                                                                                                              type GetBlockTemplateResultAux struct {
                                                                                                                                                                                                                                              	Flags string `json:"flags"`
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                GetBlockTemplateResultAux models the coinbaseaux field of the getblocktemplate command.

                                                                                                                                                                                                                                                type GetBlockTemplateResultTx

                                                                                                                                                                                                                                                type GetBlockTemplateResultTx struct {
                                                                                                                                                                                                                                                	Data      string  `json:"data"`
                                                                                                                                                                                                                                                	Hash      string  `json:"hash"`
                                                                                                                                                                                                                                                	Depends   []int64 `json:"depends"`
                                                                                                                                                                                                                                                	Fee       int64   `json:"fee"`
                                                                                                                                                                                                                                                	SigChecks int64   `json:"sigchecks"`
                                                                                                                                                                                                                                                	Size      int64   `json:"size"`
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                  GetBlockTemplateResultTx models the transactions field of the getblocktemplate command.

                                                                                                                                                                                                                                                  type GetBlockVerboseResult

                                                                                                                                                                                                                                                  type GetBlockVerboseResult struct {
                                                                                                                                                                                                                                                  	Hash          string        `json:"hash"`
                                                                                                                                                                                                                                                  	Confirmations int64         `json:"confirmations"`
                                                                                                                                                                                                                                                  	StrippedSize  int32         `json:"strippedsize"`
                                                                                                                                                                                                                                                  	Size          int32         `json:"size"`
                                                                                                                                                                                                                                                  	Height        int64         `json:"height"`
                                                                                                                                                                                                                                                  	Version       int32         `json:"version"`
                                                                                                                                                                                                                                                  	VersionHex    string        `json:"versionHex"`
                                                                                                                                                                                                                                                  	MerkleRoot    string        `json:"merkleroot"`
                                                                                                                                                                                                                                                  	Tx            []string      `json:"tx,omitempty"`
                                                                                                                                                                                                                                                  	RawTx         []TxRawResult `json:"rawtx,omitempty"` // Note: this field is always empty when verbose != 2.
                                                                                                                                                                                                                                                  	Time          int64         `json:"time"`
                                                                                                                                                                                                                                                  	Nonce         uint32        `json:"nonce"`
                                                                                                                                                                                                                                                  	Bits          string        `json:"bits"`
                                                                                                                                                                                                                                                  	Difficulty    float64       `json:"difficulty"`
                                                                                                                                                                                                                                                  	PreviousHash  string        `json:"previousblockhash"`
                                                                                                                                                                                                                                                  	NextHash      string        `json:"nextblockhash,omitempty"`
                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                    GetBlockVerboseResult models the data from the getblock command when the verbose flag is set to 1. When the verbose flag is set to 0, getblock returns a hex-encoded string. When the verbose flag is set to 1, getblock returns an object whose tx field is an array of transaction hashes. When the verbose flag is set to 2, getblock returns an object whose tx field is an array of raw transactions. Use GetBlockVerboseTxResult to unmarshal data received from passing verbose=2 to getblock.

                                                                                                                                                                                                                                                    type GetBlockVerboseTxResult

                                                                                                                                                                                                                                                    type GetBlockVerboseTxResult struct {
                                                                                                                                                                                                                                                    	Hash          string        `json:"hash"`
                                                                                                                                                                                                                                                    	Confirmations int64         `json:"confirmations"`
                                                                                                                                                                                                                                                    	StrippedSize  int32         `json:"strippedsize"`
                                                                                                                                                                                                                                                    	Size          int32         `json:"size"`
                                                                                                                                                                                                                                                    	Height        int64         `json:"height"`
                                                                                                                                                                                                                                                    	Version       int32         `json:"version"`
                                                                                                                                                                                                                                                    	VersionHex    string        `json:"versionHex"`
                                                                                                                                                                                                                                                    	MerkleRoot    string        `json:"merkleroot"`
                                                                                                                                                                                                                                                    	Tx            []TxRawResult `json:"tx,omitempty"`
                                                                                                                                                                                                                                                    	Time          int64         `json:"time"`
                                                                                                                                                                                                                                                    	Nonce         uint32        `json:"nonce"`
                                                                                                                                                                                                                                                    	Bits          string        `json:"bits"`
                                                                                                                                                                                                                                                    	Difficulty    float64       `json:"difficulty"`
                                                                                                                                                                                                                                                    	PreviousHash  string        `json:"previousblockhash"`
                                                                                                                                                                                                                                                    	NextHash      string        `json:"nextblockhash,omitempty"`
                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                      GetBlockVerboseTxResult models the data from the getblock command when the verbose flag is set to 2. When the verbose flag is set to 0, getblock returns a hex-encoded string. When the verbose flag is set to 1, getblock returns an object whose tx field is an array of transaction hashes. When the verbose flag is set to 2, getblock returns an object whose tx field is an array of raw transactions. Use GetBlockVerboseResult to unmarshal data received from passing verbose=1 to getblock.

                                                                                                                                                                                                                                                      type GetCFilterCmd

                                                                                                                                                                                                                                                      type GetCFilterCmd struct {
                                                                                                                                                                                                                                                      	Hash       string
                                                                                                                                                                                                                                                      	FilterType wire.FilterType
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                        GetCFilterCmd defines the getcfilter JSON-RPC command.

                                                                                                                                                                                                                                                        func NewGetCFilterCmd

                                                                                                                                                                                                                                                        func NewGetCFilterCmd(hash string, filterType wire.FilterType) *GetCFilterCmd

                                                                                                                                                                                                                                                          NewGetCFilterCmd returns a new instance which can be used to issue a getcfilter JSON-RPC command.

                                                                                                                                                                                                                                                          type GetCFilterHeaderCmd

                                                                                                                                                                                                                                                          type GetCFilterHeaderCmd struct {
                                                                                                                                                                                                                                                          	Hash       string
                                                                                                                                                                                                                                                          	FilterType wire.FilterType
                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                            GetCFilterHeaderCmd defines the getcfilterheader JSON-RPC command.

                                                                                                                                                                                                                                                            func NewGetCFilterHeaderCmd

                                                                                                                                                                                                                                                            func NewGetCFilterHeaderCmd(hash string,
                                                                                                                                                                                                                                                            	filterType wire.FilterType) *GetCFilterHeaderCmd

                                                                                                                                                                                                                                                              NewGetCFilterHeaderCmd returns a new instance which can be used to issue a getcfilterheader JSON-RPC command.

                                                                                                                                                                                                                                                              type GetChainTipsCmd

                                                                                                                                                                                                                                                              type GetChainTipsCmd struct{}

                                                                                                                                                                                                                                                                GetChainTipsCmd defines the getchaintips JSON-RPC command.

                                                                                                                                                                                                                                                                func NewGetChainTipsCmd

                                                                                                                                                                                                                                                                func NewGetChainTipsCmd() *GetChainTipsCmd

                                                                                                                                                                                                                                                                  NewGetChainTipsCmd returns a new instance which can be used to issue a getchaintips JSON-RPC command.

                                                                                                                                                                                                                                                                  type GetConnectionCountCmd

                                                                                                                                                                                                                                                                  type GetConnectionCountCmd struct{}

                                                                                                                                                                                                                                                                    GetConnectionCountCmd defines the getconnectioncount JSON-RPC command.

                                                                                                                                                                                                                                                                    func NewGetConnectionCountCmd

                                                                                                                                                                                                                                                                    func NewGetConnectionCountCmd() *GetConnectionCountCmd

                                                                                                                                                                                                                                                                      NewGetConnectionCountCmd returns a new instance which can be used to issue a getconnectioncount JSON-RPC command.

                                                                                                                                                                                                                                                                      type GetCurrentNetCmd

                                                                                                                                                                                                                                                                      type GetCurrentNetCmd struct{}

                                                                                                                                                                                                                                                                        GetCurrentNetCmd defines the getcurrentnet JSON-RPC command.

                                                                                                                                                                                                                                                                        func NewGetCurrentNetCmd

                                                                                                                                                                                                                                                                        func NewGetCurrentNetCmd() *GetCurrentNetCmd

                                                                                                                                                                                                                                                                          NewGetCurrentNetCmd returns a new instance which can be used to issue a getcurrentnet JSON-RPC command.

                                                                                                                                                                                                                                                                          type GetDifficultyCmd

                                                                                                                                                                                                                                                                          type GetDifficultyCmd struct{}

                                                                                                                                                                                                                                                                            GetDifficultyCmd defines the getdifficulty JSON-RPC command.

                                                                                                                                                                                                                                                                            func NewGetDifficultyCmd

                                                                                                                                                                                                                                                                            func NewGetDifficultyCmd() *GetDifficultyCmd

                                                                                                                                                                                                                                                                              NewGetDifficultyCmd returns a new instance which can be used to issue a getdifficulty JSON-RPC command.

                                                                                                                                                                                                                                                                              type GetGenerateCmd

                                                                                                                                                                                                                                                                              type GetGenerateCmd struct{}

                                                                                                                                                                                                                                                                                GetGenerateCmd defines the getgenerate JSON-RPC command.

                                                                                                                                                                                                                                                                                func NewGetGenerateCmd

                                                                                                                                                                                                                                                                                func NewGetGenerateCmd() *GetGenerateCmd

                                                                                                                                                                                                                                                                                  NewGetGenerateCmd returns a new instance which can be used to issue a getgenerate JSON-RPC command.

                                                                                                                                                                                                                                                                                  type GetHashesPerSecCmd

                                                                                                                                                                                                                                                                                  type GetHashesPerSecCmd struct{}

                                                                                                                                                                                                                                                                                    GetHashesPerSecCmd defines the gethashespersec JSON-RPC command.

                                                                                                                                                                                                                                                                                    func NewGetHashesPerSecCmd

                                                                                                                                                                                                                                                                                    func NewGetHashesPerSecCmd() *GetHashesPerSecCmd

                                                                                                                                                                                                                                                                                      NewGetHashesPerSecCmd returns a new instance which can be used to issue a gethashespersec JSON-RPC command.

                                                                                                                                                                                                                                                                                      type GetHeadersCmd

                                                                                                                                                                                                                                                                                      type GetHeadersCmd struct {
                                                                                                                                                                                                                                                                                      	BlockLocators []string `json:"blocklocators"`
                                                                                                                                                                                                                                                                                      	HashStop      string   `json:"hashstop"`
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        GetHeadersCmd defines the getheaders JSON-RPC command.

                                                                                                                                                                                                                                                                                        NOTE: This is a btcsuite extension ported from github.com/decred/dcrd/dcrjson.

                                                                                                                                                                                                                                                                                        func NewGetHeadersCmd

                                                                                                                                                                                                                                                                                        func NewGetHeadersCmd(blockLocators []string, hashStop string) *GetHeadersCmd

                                                                                                                                                                                                                                                                                          NewGetHeadersCmd returns a new instance which can be used to issue a getheaders JSON-RPC command.

                                                                                                                                                                                                                                                                                          NOTE: This is a btcsuite extension ported from github.com/decred/dcrd/dcrjson.

                                                                                                                                                                                                                                                                                          type GetInfoCmd

                                                                                                                                                                                                                                                                                          type GetInfoCmd struct{}

                                                                                                                                                                                                                                                                                            GetInfoCmd defines the getinfo JSON-RPC command.

                                                                                                                                                                                                                                                                                            func NewGetInfoCmd

                                                                                                                                                                                                                                                                                            func NewGetInfoCmd() *GetInfoCmd

                                                                                                                                                                                                                                                                                              NewGetInfoCmd returns a new instance which can be used to issue a getinfo JSON-RPC command.

                                                                                                                                                                                                                                                                                              type GetMempoolEntryCmd

                                                                                                                                                                                                                                                                                              type GetMempoolEntryCmd struct {
                                                                                                                                                                                                                                                                                              	TxID string
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                GetMempoolEntryCmd defines the getmempoolentry JSON-RPC command.

                                                                                                                                                                                                                                                                                                func NewGetMempoolEntryCmd

                                                                                                                                                                                                                                                                                                func NewGetMempoolEntryCmd(txHash string) *GetMempoolEntryCmd

                                                                                                                                                                                                                                                                                                  NewGetMempoolEntryCmd returns a new instance which can be used to issue a getmempoolentry JSON-RPC command.

                                                                                                                                                                                                                                                                                                  type GetMempoolEntryResult

                                                                                                                                                                                                                                                                                                  type GetMempoolEntryResult struct {
                                                                                                                                                                                                                                                                                                  	Size             int32    `json:"size"`
                                                                                                                                                                                                                                                                                                  	Fee              float64  `json:"fee"`
                                                                                                                                                                                                                                                                                                  	ModifiedFee      float64  `json:"modifiedfee"`
                                                                                                                                                                                                                                                                                                  	Time             int64    `json:"time"`
                                                                                                                                                                                                                                                                                                  	Height           int64    `json:"height"`
                                                                                                                                                                                                                                                                                                  	StartingPriority float64  `json:"startingpriority"`
                                                                                                                                                                                                                                                                                                  	CurrentPriority  float64  `json:"currentpriority"`
                                                                                                                                                                                                                                                                                                  	DescendantCount  int64    `json:"descendantcount"`
                                                                                                                                                                                                                                                                                                  	DescendantSize   int64    `json:"descendantsize"`
                                                                                                                                                                                                                                                                                                  	DescendantFees   float64  `json:"descendantfees"`
                                                                                                                                                                                                                                                                                                  	AncestorCount    int64    `json:"ancestorcount"`
                                                                                                                                                                                                                                                                                                  	AncestorSize     int64    `json:"ancestorsize"`
                                                                                                                                                                                                                                                                                                  	AncestorFees     float64  `json:"ancestorfees"`
                                                                                                                                                                                                                                                                                                  	Depends          []string `json:"depends"`
                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                    GetMempoolEntryResult models the data returned from the getmempoolentry command.

                                                                                                                                                                                                                                                                                                    type GetMempoolInfoCmd

                                                                                                                                                                                                                                                                                                    type GetMempoolInfoCmd struct{}

                                                                                                                                                                                                                                                                                                      GetMempoolInfoCmd defines the getmempoolinfo JSON-RPC command.

                                                                                                                                                                                                                                                                                                      func NewGetMempoolInfoCmd

                                                                                                                                                                                                                                                                                                      func NewGetMempoolInfoCmd() *GetMempoolInfoCmd

                                                                                                                                                                                                                                                                                                        NewGetMempoolInfoCmd returns a new instance which can be used to issue a getmempool JSON-RPC command.

                                                                                                                                                                                                                                                                                                        type GetMempoolInfoResult

                                                                                                                                                                                                                                                                                                        type GetMempoolInfoResult struct {
                                                                                                                                                                                                                                                                                                        	Size  int64 `json:"size"`
                                                                                                                                                                                                                                                                                                        	Bytes int64 `json:"bytes"`
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                          GetMempoolInfoResult models the data returned from the getmempoolinfo command.

                                                                                                                                                                                                                                                                                                          type GetMiningInfoCmd

                                                                                                                                                                                                                                                                                                          type GetMiningInfoCmd struct{}

                                                                                                                                                                                                                                                                                                            GetMiningInfoCmd defines the getmininginfo JSON-RPC command.

                                                                                                                                                                                                                                                                                                            func NewGetMiningInfoCmd

                                                                                                                                                                                                                                                                                                            func NewGetMiningInfoCmd() *GetMiningInfoCmd

                                                                                                                                                                                                                                                                                                              NewGetMiningInfoCmd returns a new instance which can be used to issue a getmininginfo JSON-RPC command.

                                                                                                                                                                                                                                                                                                              type GetMiningInfoResult

                                                                                                                                                                                                                                                                                                              type GetMiningInfoResult struct {
                                                                                                                                                                                                                                                                                                              	Blocks           int64   `json:"blocks"`
                                                                                                                                                                                                                                                                                                              	CurrentBlockSize uint64  `json:"currentblocksize"`
                                                                                                                                                                                                                                                                                                              	CurrentBlockTx   uint64  `json:"currentblocktx"`
                                                                                                                                                                                                                                                                                                              	Difficulty       float64 `json:"difficulty"`
                                                                                                                                                                                                                                                                                                              	Errors           string  `json:"errors"`
                                                                                                                                                                                                                                                                                                              	Generate         bool    `json:"generate"`
                                                                                                                                                                                                                                                                                                              	GenProcLimit     int32   `json:"genproclimit"`
                                                                                                                                                                                                                                                                                                              	HashesPerSec     int64   `json:"hashespersec"`
                                                                                                                                                                                                                                                                                                              	NetworkHashPS    float64 `json:"networkhashps"`
                                                                                                                                                                                                                                                                                                              	PooledTx         uint64  `json:"pooledtx"`
                                                                                                                                                                                                                                                                                                              	TestNet          bool    `json:"testnet"`
                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                GetMiningInfoResult models the data from the getmininginfo command.

                                                                                                                                                                                                                                                                                                                type GetNetTotalsCmd

                                                                                                                                                                                                                                                                                                                type GetNetTotalsCmd struct{}

                                                                                                                                                                                                                                                                                                                  GetNetTotalsCmd defines the getnettotals JSON-RPC command.

                                                                                                                                                                                                                                                                                                                  func NewGetNetTotalsCmd

                                                                                                                                                                                                                                                                                                                  func NewGetNetTotalsCmd() *GetNetTotalsCmd

                                                                                                                                                                                                                                                                                                                    NewGetNetTotalsCmd returns a new instance which can be used to issue a getnettotals JSON-RPC command.

                                                                                                                                                                                                                                                                                                                    type GetNetTotalsResult

                                                                                                                                                                                                                                                                                                                    type GetNetTotalsResult struct {
                                                                                                                                                                                                                                                                                                                    	TotalBytesRecv uint64 `json:"totalbytesrecv"`
                                                                                                                                                                                                                                                                                                                    	TotalBytesSent uint64 `json:"totalbytessent"`
                                                                                                                                                                                                                                                                                                                    	TimeMillis     int64  `json:"timemillis"`
                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                      GetNetTotalsResult models the data returned from the getnettotals command.

                                                                                                                                                                                                                                                                                                                      type GetNetworkHashPSCmd

                                                                                                                                                                                                                                                                                                                      type GetNetworkHashPSCmd struct {
                                                                                                                                                                                                                                                                                                                      	Blocks *int `jsonrpcdefault:"120"`
                                                                                                                                                                                                                                                                                                                      	Height *int `jsonrpcdefault:"-1"`
                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                        GetNetworkHashPSCmd defines the getnetworkhashps JSON-RPC command.

                                                                                                                                                                                                                                                                                                                        func NewGetNetworkHashPSCmd

                                                                                                                                                                                                                                                                                                                        func NewGetNetworkHashPSCmd(numBlocks, height *int) *GetNetworkHashPSCmd

                                                                                                                                                                                                                                                                                                                          NewGetNetworkHashPSCmd returns a new instance which can be used to issue a getnetworkhashps JSON-RPC command.

                                                                                                                                                                                                                                                                                                                          The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                          type GetNetworkInfoCmd

                                                                                                                                                                                                                                                                                                                          type GetNetworkInfoCmd struct{}

                                                                                                                                                                                                                                                                                                                            GetNetworkInfoCmd defines the getnetworkinfo JSON-RPC command.

                                                                                                                                                                                                                                                                                                                            func NewGetNetworkInfoCmd

                                                                                                                                                                                                                                                                                                                            func NewGetNetworkInfoCmd() *GetNetworkInfoCmd

                                                                                                                                                                                                                                                                                                                              NewGetNetworkInfoCmd returns a new instance which can be used to issue a getnetworkinfo JSON-RPC command.

                                                                                                                                                                                                                                                                                                                              type GetNetworkInfoResult

                                                                                                                                                                                                                                                                                                                              type GetNetworkInfoResult struct {
                                                                                                                                                                                                                                                                                                                              	Version         int32                  `json:"version"`
                                                                                                                                                                                                                                                                                                                              	SubVersion      string                 `json:"subversion"`
                                                                                                                                                                                                                                                                                                                              	ProtocolVersion int32                  `json:"protocolversion"`
                                                                                                                                                                                                                                                                                                                              	LocalServices   string                 `json:"localservices"`
                                                                                                                                                                                                                                                                                                                              	LocalRelay      bool                   `json:"localrelay"`
                                                                                                                                                                                                                                                                                                                              	TimeOffset      int64                  `json:"timeoffset"`
                                                                                                                                                                                                                                                                                                                              	Connections     int32                  `json:"connections"`
                                                                                                                                                                                                                                                                                                                              	NetworkActive   bool                   `json:"networkactive"`
                                                                                                                                                                                                                                                                                                                              	Networks        []NetworksResult       `json:"networks"`
                                                                                                                                                                                                                                                                                                                              	RelayFee        float64                `json:"relayfee"`
                                                                                                                                                                                                                                                                                                                              	IncrementalFee  float64                `json:"incrementalfee"`
                                                                                                                                                                                                                                                                                                                              	LocalAddresses  []LocalAddressesResult `json:"localaddresses"`
                                                                                                                                                                                                                                                                                                                              	Warnings        string                 `json:"warnings"`
                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                GetNetworkInfoResult models the data returned from the getnetworkinfo command.

                                                                                                                                                                                                                                                                                                                                type GetNewAddressCmd

                                                                                                                                                                                                                                                                                                                                type GetNewAddressCmd struct {
                                                                                                                                                                                                                                                                                                                                	Account *string
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                  GetNewAddressCmd defines the getnewaddress JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                  func NewGetNewAddressCmd

                                                                                                                                                                                                                                                                                                                                  func NewGetNewAddressCmd(account *string) *GetNewAddressCmd

                                                                                                                                                                                                                                                                                                                                    NewGetNewAddressCmd returns a new instance which can be used to issue a getnewaddress JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                    The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                    type GetPeerInfoCmd

                                                                                                                                                                                                                                                                                                                                    type GetPeerInfoCmd struct{}

                                                                                                                                                                                                                                                                                                                                      GetPeerInfoCmd defines the getpeerinfo JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                      func NewGetPeerInfoCmd

                                                                                                                                                                                                                                                                                                                                      func NewGetPeerInfoCmd() *GetPeerInfoCmd

                                                                                                                                                                                                                                                                                                                                        NewGetPeerInfoCmd returns a new instance which can be used to issue a getpeer JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                        type GetPeerInfoResult

                                                                                                                                                                                                                                                                                                                                        type GetPeerInfoResult struct {
                                                                                                                                                                                                                                                                                                                                        	ID             int32   `json:"id"`
                                                                                                                                                                                                                                                                                                                                        	Addr           string  `json:"addr"`
                                                                                                                                                                                                                                                                                                                                        	AddrLocal      string  `json:"addrlocal,omitempty"`
                                                                                                                                                                                                                                                                                                                                        	Services       string  `json:"services"`
                                                                                                                                                                                                                                                                                                                                        	ServicesStr    string  `json:"servicesStr"`
                                                                                                                                                                                                                                                                                                                                        	RelayTxes      bool    `json:"relaytxes"`
                                                                                                                                                                                                                                                                                                                                        	LastSend       int64   `json:"lastsend"`
                                                                                                                                                                                                                                                                                                                                        	LastRecv       int64   `json:"lastrecv"`
                                                                                                                                                                                                                                                                                                                                        	BytesSent      uint64  `json:"bytessent"`
                                                                                                                                                                                                                                                                                                                                        	BytesRecv      uint64  `json:"bytesrecv"`
                                                                                                                                                                                                                                                                                                                                        	ConnTime       int64   `json:"conntime"`
                                                                                                                                                                                                                                                                                                                                        	TimeOffset     int64   `json:"timeoffset"`
                                                                                                                                                                                                                                                                                                                                        	PingTime       float64 `json:"pingtime"`
                                                                                                                                                                                                                                                                                                                                        	PingWait       float64 `json:"pingwait,omitempty"`
                                                                                                                                                                                                                                                                                                                                        	Version        uint32  `json:"version"`
                                                                                                                                                                                                                                                                                                                                        	SubVer         string  `json:"subver"`
                                                                                                                                                                                                                                                                                                                                        	Inbound        bool    `json:"inbound"`
                                                                                                                                                                                                                                                                                                                                        	StartingHeight int32   `json:"startingheight"`
                                                                                                                                                                                                                                                                                                                                        	CurrentHeight  int32   `json:"currentheight,omitempty"`
                                                                                                                                                                                                                                                                                                                                        	BanScore       int32   `json:"banscore"`
                                                                                                                                                                                                                                                                                                                                        	Whitelisted    bool    `json:"whitelisted"`
                                                                                                                                                                                                                                                                                                                                        	FeeFilter      int64   `json:"feefilter"`
                                                                                                                                                                                                                                                                                                                                        	SyncNode       bool    `json:"syncnode"`
                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                          GetPeerInfoResult models the data returned from the getpeerinfo command.

                                                                                                                                                                                                                                                                                                                                          type GetRawChangeAddressCmd

                                                                                                                                                                                                                                                                                                                                          type GetRawChangeAddressCmd struct {
                                                                                                                                                                                                                                                                                                                                          	Account *string
                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                            GetRawChangeAddressCmd defines the getrawchangeaddress JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                            func NewGetRawChangeAddressCmd

                                                                                                                                                                                                                                                                                                                                            func NewGetRawChangeAddressCmd(account *string) *GetRawChangeAddressCmd

                                                                                                                                                                                                                                                                                                                                              NewGetRawChangeAddressCmd returns a new instance which can be used to issue a getrawchangeaddress JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                              The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                              type GetRawMempoolCmd

                                                                                                                                                                                                                                                                                                                                              type GetRawMempoolCmd struct {
                                                                                                                                                                                                                                                                                                                                              	Verbose *bool `jsonrpcdefault:"false"`
                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                GetRawMempoolCmd defines the getmempool JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                func NewGetRawMempoolCmd

                                                                                                                                                                                                                                                                                                                                                func NewGetRawMempoolCmd(verbose *bool) *GetRawMempoolCmd

                                                                                                                                                                                                                                                                                                                                                  NewGetRawMempoolCmd returns a new instance which can be used to issue a getrawmempool JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                  The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                  type GetRawMempoolVerboseResult

                                                                                                                                                                                                                                                                                                                                                  type GetRawMempoolVerboseResult struct {
                                                                                                                                                                                                                                                                                                                                                  	Size             int32    `json:"size"`
                                                                                                                                                                                                                                                                                                                                                  	Fee              float64  `json:"fee"`
                                                                                                                                                                                                                                                                                                                                                  	Time             int64    `json:"time"`
                                                                                                                                                                                                                                                                                                                                                  	Height           int64    `json:"height"`
                                                                                                                                                                                                                                                                                                                                                  	StartingPriority float64  `json:"startingpriority"`
                                                                                                                                                                                                                                                                                                                                                  	CurrentPriority  float64  `json:"currentpriority"`
                                                                                                                                                                                                                                                                                                                                                  	Depends          []string `json:"depends"`
                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                    GetRawMempoolVerboseResult models the data returned from the getrawmempool command when the verbose flag is set. When the verbose flag is not set, getrawmempool returns an array of transaction hashes.

                                                                                                                                                                                                                                                                                                                                                    type GetRawTransactionCmd

                                                                                                                                                                                                                                                                                                                                                    type GetRawTransactionCmd struct {
                                                                                                                                                                                                                                                                                                                                                    	Txid    string
                                                                                                                                                                                                                                                                                                                                                    	Verbose *VerboseLevel `jsonrpcdefault:"0"`
                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                      GetRawTransactionCmd defines the getrawtransaction JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                      NOTE: This field is an int versus a bool to remain compatible with Bitcoin Core even though it really should be a bool.

                                                                                                                                                                                                                                                                                                                                                      func NewGetRawTransactionCmd

                                                                                                                                                                                                                                                                                                                                                      func NewGetRawTransactionCmd(txHash string, verbose *VerboseLevel) *GetRawTransactionCmd

                                                                                                                                                                                                                                                                                                                                                        NewGetRawTransactionCmd returns a new instance which can be used to issue a getrawtransaction JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                        The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                        type GetReceivedByAccountCmd

                                                                                                                                                                                                                                                                                                                                                        type GetReceivedByAccountCmd struct {
                                                                                                                                                                                                                                                                                                                                                        	Account string
                                                                                                                                                                                                                                                                                                                                                        	MinConf *int `jsonrpcdefault:"1"`
                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                          GetReceivedByAccountCmd defines the getreceivedbyaccount JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                          func NewGetReceivedByAccountCmd

                                                                                                                                                                                                                                                                                                                                                          func NewGetReceivedByAccountCmd(account string, minConf *int) *GetReceivedByAccountCmd

                                                                                                                                                                                                                                                                                                                                                            NewGetReceivedByAccountCmd returns a new instance which can be used to issue a getreceivedbyaccount JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                            The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                            type GetReceivedByAddressCmd

                                                                                                                                                                                                                                                                                                                                                            type GetReceivedByAddressCmd struct {
                                                                                                                                                                                                                                                                                                                                                            	Address string
                                                                                                                                                                                                                                                                                                                                                            	MinConf *int `jsonrpcdefault:"1"`
                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                              GetReceivedByAddressCmd defines the getreceivedbyaddress JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                              func NewGetReceivedByAddressCmd

                                                                                                                                                                                                                                                                                                                                                              func NewGetReceivedByAddressCmd(address string, minConf *int) *GetReceivedByAddressCmd

                                                                                                                                                                                                                                                                                                                                                                NewGetReceivedByAddressCmd returns a new instance which can be used to issue a getreceivedbyaddress JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                type GetTransactionCmd

                                                                                                                                                                                                                                                                                                                                                                type GetTransactionCmd struct {
                                                                                                                                                                                                                                                                                                                                                                	Txid             string
                                                                                                                                                                                                                                                                                                                                                                	IncludeWatchOnly *bool `jsonrpcdefault:"false"`
                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                  GetTransactionCmd defines the gettransaction JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                  func NewGetTransactionCmd

                                                                                                                                                                                                                                                                                                                                                                  func NewGetTransactionCmd(txHash string, includeWatchOnly *bool) *GetTransactionCmd

                                                                                                                                                                                                                                                                                                                                                                    NewGetTransactionCmd returns a new instance which can be used to issue a gettransaction JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                    The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                    type GetTransactionDetailsResult

                                                                                                                                                                                                                                                                                                                                                                    type GetTransactionDetailsResult struct {
                                                                                                                                                                                                                                                                                                                                                                    	Account           string   `json:"account"`
                                                                                                                                                                                                                                                                                                                                                                    	Address           string   `json:"address,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                    	Amount            float64  `json:"amount"`
                                                                                                                                                                                                                                                                                                                                                                    	Category          string   `json:"category"`
                                                                                                                                                                                                                                                                                                                                                                    	InvolvesWatchOnly bool     `json:"involveswatchonly,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                    	Fee               *float64 `json:"fee,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                    	Vout              uint32   `json:"vout"`
                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                      GetTransactionDetailsResult models the details data from the gettransaction command.

                                                                                                                                                                                                                                                                                                                                                                      This models the "short" version of the ListTransactionsResult type, which excludes fields common to the transaction. These common fields are instead part of the GetTransactionResult.

                                                                                                                                                                                                                                                                                                                                                                      type GetTransactionResult

                                                                                                                                                                                                                                                                                                                                                                      type GetTransactionResult struct {
                                                                                                                                                                                                                                                                                                                                                                      	Amount          float64                       `json:"amount"`
                                                                                                                                                                                                                                                                                                                                                                      	Fee             float64                       `json:"fee,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                      	Confirmations   int64                         `json:"confirmations"`
                                                                                                                                                                                                                                                                                                                                                                      	BlockHash       string                        `json:"blockhash"`
                                                                                                                                                                                                                                                                                                                                                                      	BlockIndex      int64                         `json:"blockindex"`
                                                                                                                                                                                                                                                                                                                                                                      	BlockTime       int64                         `json:"blocktime"`
                                                                                                                                                                                                                                                                                                                                                                      	TxID            string                        `json:"txid"`
                                                                                                                                                                                                                                                                                                                                                                      	WalletConflicts []string                      `json:"walletconflicts"`
                                                                                                                                                                                                                                                                                                                                                                      	Time            int64                         `json:"time"`
                                                                                                                                                                                                                                                                                                                                                                      	TimeReceived    int64                         `json:"timereceived"`
                                                                                                                                                                                                                                                                                                                                                                      	Details         []GetTransactionDetailsResult `json:"details"`
                                                                                                                                                                                                                                                                                                                                                                      	Hex             string                        `json:"hex"`
                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                        GetTransactionResult models the data from the gettransaction command.

                                                                                                                                                                                                                                                                                                                                                                        type GetTxOutCmd

                                                                                                                                                                                                                                                                                                                                                                        type GetTxOutCmd struct {
                                                                                                                                                                                                                                                                                                                                                                        	Txid           string
                                                                                                                                                                                                                                                                                                                                                                        	Vout           uint32
                                                                                                                                                                                                                                                                                                                                                                        	IncludeMempool *bool `jsonrpcdefault:"true"`
                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                          GetTxOutCmd defines the gettxout JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                          func NewGetTxOutCmd

                                                                                                                                                                                                                                                                                                                                                                          func NewGetTxOutCmd(txHash string, vout uint32, includeMempool *bool) *GetTxOutCmd

                                                                                                                                                                                                                                                                                                                                                                            NewGetTxOutCmd returns a new instance which can be used to issue a gettxout JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                            The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                            type GetTxOutProofCmd

                                                                                                                                                                                                                                                                                                                                                                            type GetTxOutProofCmd struct {
                                                                                                                                                                                                                                                                                                                                                                            	TxIDs     []string
                                                                                                                                                                                                                                                                                                                                                                            	BlockHash *string
                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                              GetTxOutProofCmd defines the gettxoutproof JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                              func NewGetTxOutProofCmd

                                                                                                                                                                                                                                                                                                                                                                              func NewGetTxOutProofCmd(txIDs []string, blockHash *string) *GetTxOutProofCmd

                                                                                                                                                                                                                                                                                                                                                                                NewGetTxOutProofCmd returns a new instance which can be used to issue a gettxoutproof JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                type GetTxOutResult

                                                                                                                                                                                                                                                                                                                                                                                type GetTxOutResult struct {
                                                                                                                                                                                                                                                                                                                                                                                	BestBlock     string             `json:"bestblock"`
                                                                                                                                                                                                                                                                                                                                                                                	Confirmations int64              `json:"confirmations"`
                                                                                                                                                                                                                                                                                                                                                                                	Value         float64            `json:"value"`
                                                                                                                                                                                                                                                                                                                                                                                	ScriptPubKey  ScriptPubKeyResult `json:"scriptPubKey"`
                                                                                                                                                                                                                                                                                                                                                                                	Coinbase      bool               `json:"coinbase"`
                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                  GetTxOutResult models the data from the gettxout command.

                                                                                                                                                                                                                                                                                                                                                                                  type GetTxOutSetInfoCmd

                                                                                                                                                                                                                                                                                                                                                                                  type GetTxOutSetInfoCmd struct{}

                                                                                                                                                                                                                                                                                                                                                                                    GetTxOutSetInfoCmd defines the gettxoutsetinfo JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                    func NewGetTxOutSetInfoCmd

                                                                                                                                                                                                                                                                                                                                                                                    func NewGetTxOutSetInfoCmd() *GetTxOutSetInfoCmd

                                                                                                                                                                                                                                                                                                                                                                                      NewGetTxOutSetInfoCmd returns a new instance which can be used to issue a gettxoutsetinfo JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                      type GetUnconfirmedBalanceCmd

                                                                                                                                                                                                                                                                                                                                                                                      type GetUnconfirmedBalanceCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                      	Account *string
                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                        GetUnconfirmedBalanceCmd defines the getunconfirmedbalance JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                        func NewGetUnconfirmedBalanceCmd

                                                                                                                                                                                                                                                                                                                                                                                        func NewGetUnconfirmedBalanceCmd(account *string) *GetUnconfirmedBalanceCmd

                                                                                                                                                                                                                                                                                                                                                                                          NewGetUnconfirmedBalanceCmd returns a new instance which can be used to issue a getunconfirmedbalance JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                          The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                          type GetWalletInfoCmd

                                                                                                                                                                                                                                                                                                                                                                                          type GetWalletInfoCmd struct{}

                                                                                                                                                                                                                                                                                                                                                                                            GetWalletInfoCmd defines the getwalletinfo JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                            func NewGetWalletInfoCmd

                                                                                                                                                                                                                                                                                                                                                                                            func NewGetWalletInfoCmd() *GetWalletInfoCmd

                                                                                                                                                                                                                                                                                                                                                                                              NewGetWalletInfoCmd returns a new instance which can be used to issue a getwalletinfo JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                              type GetWorkCmd

                                                                                                                                                                                                                                                                                                                                                                                              type GetWorkCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                              	Data *string
                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                GetWorkCmd defines the getwork JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                func NewGetWorkCmd

                                                                                                                                                                                                                                                                                                                                                                                                func NewGetWorkCmd(data *string) *GetWorkCmd

                                                                                                                                                                                                                                                                                                                                                                                                  NewGetWorkCmd returns a new instance which can be used to issue a getwork JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                  The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                  type GetWorkResult

                                                                                                                                                                                                                                                                                                                                                                                                  type GetWorkResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                  	Data     string `json:"data"`
                                                                                                                                                                                                                                                                                                                                                                                                  	Hash1    string `json:"hash1"`
                                                                                                                                                                                                                                                                                                                                                                                                  	Midstate string `json:"midstate"`
                                                                                                                                                                                                                                                                                                                                                                                                  	Target   string `json:"target"`
                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                    GetWorkResult models the data from the getwork command.

                                                                                                                                                                                                                                                                                                                                                                                                    type HelpCmd

                                                                                                                                                                                                                                                                                                                                                                                                    type HelpCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                    	Command *string
                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                      HelpCmd defines the help JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                      func NewHelpCmd

                                                                                                                                                                                                                                                                                                                                                                                                      func NewHelpCmd(command *string) *HelpCmd

                                                                                                                                                                                                                                                                                                                                                                                                        NewHelpCmd returns a new instance which can be used to issue a help JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                        The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                        type ImportAddressCmd

                                                                                                                                                                                                                                                                                                                                                                                                        type ImportAddressCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                        	Address string
                                                                                                                                                                                                                                                                                                                                                                                                        	Account string
                                                                                                                                                                                                                                                                                                                                                                                                        	Rescan  *bool `jsonrpcdefault:"true"`
                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                          ImportAddressCmd defines the importaddress JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                          func NewImportAddressCmd

                                                                                                                                                                                                                                                                                                                                                                                                          func NewImportAddressCmd(address string, account string, rescan *bool) *ImportAddressCmd

                                                                                                                                                                                                                                                                                                                                                                                                            NewImportAddressCmd returns a new instance which can be used to issue an importaddress JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                            type ImportPrivKeyCmd

                                                                                                                                                                                                                                                                                                                                                                                                            type ImportPrivKeyCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                            	PrivKey string
                                                                                                                                                                                                                                                                                                                                                                                                            	Label   *string
                                                                                                                                                                                                                                                                                                                                                                                                            	Rescan  *bool `jsonrpcdefault:"true"`
                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                              ImportPrivKeyCmd defines the importprivkey JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                              func NewImportPrivKeyCmd

                                                                                                                                                                                                                                                                                                                                                                                                              func NewImportPrivKeyCmd(privKey string, label *string, rescan *bool) *ImportPrivKeyCmd

                                                                                                                                                                                                                                                                                                                                                                                                                NewImportPrivKeyCmd returns a new instance which can be used to issue a importprivkey JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                type ImportPubKeyCmd

                                                                                                                                                                                                                                                                                                                                                                                                                type ImportPubKeyCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                	PubKey string
                                                                                                                                                                                                                                                                                                                                                                                                                	Rescan *bool `jsonrpcdefault:"true"`
                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                  ImportPubKeyCmd defines the importpubkey JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                  func NewImportPubKeyCmd

                                                                                                                                                                                                                                                                                                                                                                                                                  func NewImportPubKeyCmd(pubKey string, rescan *bool) *ImportPubKeyCmd

                                                                                                                                                                                                                                                                                                                                                                                                                    NewImportPubKeyCmd returns a new instance which can be used to issue an importpubkey JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                    type ImportWalletCmd

                                                                                                                                                                                                                                                                                                                                                                                                                    type ImportWalletCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                    	Filename string
                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                      ImportWalletCmd defines the importwallet JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                      func NewImportWalletCmd

                                                                                                                                                                                                                                                                                                                                                                                                                      func NewImportWalletCmd(filename string) *ImportWalletCmd

                                                                                                                                                                                                                                                                                                                                                                                                                        NewImportWalletCmd returns a new instance which can be used to issue a importwallet JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                        type InfoChainResult

                                                                                                                                                                                                                                                                                                                                                                                                                        type InfoChainResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                        	Version         int32   `json:"version"`
                                                                                                                                                                                                                                                                                                                                                                                                                        	ProtocolVersion int32   `json:"protocolversion"`
                                                                                                                                                                                                                                                                                                                                                                                                                        	Blocks          int32   `json:"blocks"`
                                                                                                                                                                                                                                                                                                                                                                                                                        	TimeOffset      int64   `json:"timeoffset"`
                                                                                                                                                                                                                                                                                                                                                                                                                        	Connections     int32   `json:"connections"`
                                                                                                                                                                                                                                                                                                                                                                                                                        	Proxy           string  `json:"proxy"`
                                                                                                                                                                                                                                                                                                                                                                                                                        	Difficulty      float64 `json:"difficulty"`
                                                                                                                                                                                                                                                                                                                                                                                                                        	TestNet         bool    `json:"testnet"`
                                                                                                                                                                                                                                                                                                                                                                                                                        	RelayFee        float64 `json:"relayfee"`
                                                                                                                                                                                                                                                                                                                                                                                                                        	Errors          string  `json:"errors"`
                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                          InfoChainResult models the data returned by the chain server getinfo command.

                                                                                                                                                                                                                                                                                                                                                                                                                          type InfoWalletResult

                                                                                                                                                                                                                                                                                                                                                                                                                          type InfoWalletResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                          	Version         int32   `json:"version"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	ProtocolVersion int32   `json:"protocolversion"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	WalletVersion   int32   `json:"walletversion"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	Balance         float64 `json:"balance"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	Blocks          int32   `json:"blocks"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	TimeOffset      int64   `json:"timeoffset"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	Connections     int32   `json:"connections"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	Proxy           string  `json:"proxy"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	Difficulty      float64 `json:"difficulty"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	TestNet         bool    `json:"testnet"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	KeypoolOldest   int64   `json:"keypoololdest"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	KeypoolSize     int32   `json:"keypoolsize"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	UnlockedUntil   int64   `json:"unlocked_until"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	PaytxFee        float64 `json:"paytxfee"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	RelayFee        float64 `json:"relayfee"`
                                                                                                                                                                                                                                                                                                                                                                                                                          	Errors          string  `json:"errors"`
                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                            InfoWalletResult models the data returned by the wallet server getinfo command.

                                                                                                                                                                                                                                                                                                                                                                                                                            type InvalidateBlockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                            type InvalidateBlockCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                            	BlockHash string
                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                              InvalidateBlockCmd defines the invalidateblock JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                              func NewInvalidateBlockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                              func NewInvalidateBlockCmd(blockHash string) *InvalidateBlockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                NewInvalidateBlockCmd returns a new instance which can be used to issue a invalidateblock JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                type KeyPoolRefillCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                type KeyPoolRefillCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                	NewSize *uint `jsonrpcdefault:"100"`
                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                  KeyPoolRefillCmd defines the keypoolrefill JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewKeyPoolRefillCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewKeyPoolRefillCmd(newSize *uint) *KeyPoolRefillCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                    NewKeyPoolRefillCmd returns a new instance which can be used to issue a keypoolrefill JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                    The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                    type ListAccountsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                    type ListAccountsCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                    	MinConf *int `jsonrpcdefault:"1"`
                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                      ListAccountsCmd defines the listaccounts JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewListAccountsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewListAccountsCmd(minConf *int) *ListAccountsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                        NewListAccountsCmd returns a new instance which can be used to issue a listaccounts JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                        The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                        type ListAddressGroupingsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                        type ListAddressGroupingsCmd struct{}

                                                                                                                                                                                                                                                                                                                                                                                                                                          ListAddressGroupingsCmd defines the listaddressgroupings JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewListAddressGroupingsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewListAddressGroupingsCmd() *ListAddressGroupingsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                            NewListAddressGroupingsCmd returns a new instance which can be used to issue a listaddressgroupoings JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                            type ListAddressTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                            type ListAddressTransactionsCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                            	Addresses []string
                                                                                                                                                                                                                                                                                                                                                                                                                                            	Account   *string
                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                              ListAddressTransactionsCmd defines the listaddresstransactions JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewListAddressTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewListAddressTransactionsCmd(addresses []string, account *string) *ListAddressTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                NewListAddressTransactionsCmd returns a new instance which can be used to issue a listaddresstransactions JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                type ListAllTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                type ListAllTransactionsCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                	Account *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                  ListAllTransactionsCmd defines the listalltransactions JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewListAllTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewListAllTransactionsCmd(account *string) *ListAllTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewListAllTransactionsCmd returns a new instance which can be used to issue a listalltransactions JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ListLockUnspentCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ListLockUnspentCmd struct{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      ListLockUnspentCmd defines the listlockunspent JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewListLockUnspentCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewListLockUnspentCmd() *ListLockUnspentCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewListLockUnspentCmd returns a new instance which can be used to issue a listlockunspent JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ListReceivedByAccountCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ListReceivedByAccountCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	MinConf          *int  `jsonrpcdefault:"1"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	IncludeEmpty     *bool `jsonrpcdefault:"false"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        	IncludeWatchOnly *bool `jsonrpcdefault:"false"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                          ListReceivedByAccountCmd defines the listreceivedbyaccount JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewListReceivedByAccountCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewListReceivedByAccountCmd(minConf *int, includeEmpty, includeWatchOnly *bool) *ListReceivedByAccountCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewListReceivedByAccountCmd returns a new instance which can be used to issue a listreceivedbyaccount JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ListReceivedByAccountResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ListReceivedByAccountResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Account       string  `json:"account"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Amount        float64 `json:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Confirmations uint64  `json:"confirmations"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                              ListReceivedByAccountResult models the data from the listreceivedbyaccount command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ListReceivedByAddressCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ListReceivedByAddressCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	MinConf          *int  `jsonrpcdefault:"1"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	IncludeEmpty     *bool `jsonrpcdefault:"false"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              	IncludeWatchOnly *bool `jsonrpcdefault:"false"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                ListReceivedByAddressCmd defines the listreceivedbyaddress JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewListReceivedByAddressCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewListReceivedByAddressCmd(minConf *int, includeEmpty, includeWatchOnly *bool) *ListReceivedByAddressCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewListReceivedByAddressCmd returns a new instance which can be used to issue a listreceivedbyaddress JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ListReceivedByAddressResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type ListReceivedByAddressResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Account           string   `json:"account"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Address           string   `json:"address"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Amount            float64  `json:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Confirmations     uint64   `json:"confirmations"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	TxIDs             []string `json:"txids,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	InvolvesWatchonly bool     `json:"involvesWatchonly,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ListReceivedByAddressResult models the data from the listreceivedbyaddress command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ListSinceBlockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ListSinceBlockCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	BlockHash           *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	TargetConfirmations *int  `jsonrpcdefault:"1"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	IncludeWatchOnly    *bool `jsonrpcdefault:"false"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ListSinceBlockCmd defines the listsinceblock JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewListSinceBlockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewListSinceBlockCmd(blockHash *string, targetConfirms *int, includeWatchOnly *bool) *ListSinceBlockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewListSinceBlockCmd returns a new instance which can be used to issue a listsinceblock JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ListSinceBlockResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type ListSinceBlockResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Transactions []ListTransactionsResult `json:"transactions"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	LastBlock    string                   `json:"lastblock"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ListSinceBlockResult models the data from the listsinceblock command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ListTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ListTransactionsCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Account          *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Count            *int  `jsonrpcdefault:"10"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	From             *int  `jsonrpcdefault:"0"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	IncludeWatchOnly *bool `jsonrpcdefault:"false"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ListTransactionsCmd defines the listtransactions JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewListTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewListTransactionsCmd(account *string, count, from *int, includeWatchOnly *bool) *ListTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewListTransactionsCmd returns a new instance which can be used to issue a listtransactions JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ListTransactionsResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ListTransactionsResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Abandoned         bool     `json:"abandoned"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Account           string   `json:"account"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Address           string   `json:"address,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Amount            float64  `json:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	BIP125Replaceable string   `json:"bip125-replaceable,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	BlockHash         string   `json:"blockhash,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	BlockIndex        *int64   `json:"blockindex,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	BlockTime         int64    `json:"blocktime,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Category          string   `json:"category"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Confirmations     int64    `json:"confirmations"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Fee               *float64 `json:"fee,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Generated         bool     `json:"generated,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	InvolvesWatchOnly bool     `json:"involveswatchonly,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Time              int64    `json:"time"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TimeReceived      int64    `json:"timereceived"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Trusted           bool     `json:"trusted"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TxID              string   `json:"txid"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Vout              uint32   `json:"vout"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	WalletConflicts   []string `json:"walletconflicts"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Comment           string   `json:"comment,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	OtherAccount      string   `json:"otheraccount,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ListTransactionsResult models the data from the listtransactions command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ListUnspentCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ListUnspentCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	MinConf   *int `jsonrpcdefault:"1"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	MaxConf   *int `jsonrpcdefault:"9999999"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Addresses *[]string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ListUnspentCmd defines the listunspent JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewListUnspentCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewListUnspentCmd(minConf, maxConf *int, addresses *[]string) *ListUnspentCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewListUnspentCmd returns a new instance which can be used to issue a listunspent JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ListUnspentResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ListUnspentResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	TxID          string  `json:"txid"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Vout          uint32  `json:"vout"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Address       string  `json:"address"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Account       string  `json:"account"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ScriptPubKey  string  `json:"scriptPubKey"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	RedeemScript  string  `json:"redeemScript,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Amount        float64 `json:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Confirmations int64   `json:"confirmations"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Spendable     bool    `json:"spendable"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ListUnspentResult models a successful response from the listunspent request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type LoadTxFilterCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type LoadTxFilterCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Reload    bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Addresses []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	OutPoints []OutPoint
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        LoadTxFilterCmd defines the loadtxfilter request parameters to load or reload a transaction filter.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NOTE: This is a btcd extension ported from github.com/decred/dcrd/dcrjson and requires a websocket connection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewLoadTxFilterCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewLoadTxFilterCmd(reload bool, addresses []string, outPoints []OutPoint) *LoadTxFilterCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewLoadTxFilterCmd returns a new instance which can be used to issue a loadtxfilter JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NOTE: This is a btcd extension ported from github.com/decred/dcrd/dcrjson and requires a websocket connection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type LocalAddressesResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type LocalAddressesResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Address string `json:"address"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Port    uint16 `json:"port"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Score   int32  `json:"score"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            LocalAddressesResult models the localaddresses data from the getnetworkinfo command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type LockUnspentCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type LockUnspentCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Unlock       bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Transactions []TransactionInput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              LockUnspentCmd defines the lockunspent JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewLockUnspentCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewLockUnspentCmd(unlock bool, transactions []TransactionInput) *LockUnspentCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NewLockUnspentCmd returns a new instance which can be used to issue a lockunspent JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MoveCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MoveCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	FromAccount string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ToAccount   string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Amount      float64 // In BTC
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	MinConf     *int    `jsonrpcdefault:"1"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Comment     *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MoveCmd defines the move JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewMoveCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewMoveCmd(fromAccount, toAccount string, amount float64, minConf *int, comment *string) *MoveCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewMoveCmd returns a new instance which can be used to issue a move JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type NetworksResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type NetworksResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Name                      string `json:"name"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Limited                   bool   `json:"limited"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Reachable                 bool   `json:"reachable"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Proxy                     string `json:"proxy"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ProxyRandomizeCredentials bool   `json:"proxy_randomize_credentials"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NetworksResult models the networks data from the getnetworkinfo command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type NewTxNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type NewTxNtfn struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Account string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Details ListTransactionsResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewTxNtfn defines the newtx JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewNewTxNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewNewTxNtfn(account string, details ListTransactionsResult) *NewTxNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewNewTxNtfn returns a new instance which can be used to issue a newtx JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NodeCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NodeCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	SubCmd        NodeSubCmd `jsonrpcusage:"\"connect|remove|disconnect\""`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Target        string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ConnectSubCmd *string `jsonrpcusage:"\"perm|temp\""`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NodeCmd defines the dropnode JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewNodeCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewNodeCmd(subCmd NodeSubCmd, target string, connectSubCmd *string) *NodeCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewNodeCmd returns a new instance which can be used to issue a `node` JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NodeSubCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NodeSubCmd string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NodeSubCmd defines the type used in the addnode JSON-RPC command for the sub command field.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// NConnect indicates the specified host that should be connected to.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	NConnect NodeSubCmd = "connect"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// NRemove indicates the specified peer that should be removed as a
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// persistent peer.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	NRemove NodeSubCmd = "remove"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// NDisconnect indicates the specified peer should be disonnected.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	NDisconnect NodeSubCmd = "disconnect"
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NotifyBlocksCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NotifyBlocksCmd struct{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NotifyBlocksCmd defines the notifyblocks JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewNotifyBlocksCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewNotifyBlocksCmd() *NotifyBlocksCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewNotifyBlocksCmd returns a new instance which can be used to issue a notifyblocks JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type NotifyNewTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type NotifyNewTransactionsCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Verbose *bool `jsonrpcdefault:"false"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NotifyNewTransactionsCmd defines the notifynewtransactions JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewNotifyNewTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewNotifyNewTransactionsCmd(verbose *bool) *NotifyNewTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewNotifyNewTransactionsCmd returns a new instance which can be used to issue a notifynewtransactions JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NotifyReceivedCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NotifyReceivedCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Addresses []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NotifyReceivedCmd defines the notifyreceived JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Deprecated: Use LoadTxFilterCmd instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewNotifyReceivedCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewNotifyReceivedCmd(addresses []string) *NotifyReceivedCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewNotifyReceivedCmd returns a new instance which can be used to issue a notifyreceived JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deprecated: Use NewLoadTxFilterCmd instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type NotifySpentCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type NotifySpentCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	OutPoints []OutPoint
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NotifySpentCmd defines the notifyspent JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Deprecated: Use LoadTxFilterCmd instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewNotifySpentCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewNotifySpentCmd(outPoints []OutPoint) *NotifySpentCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NewNotifySpentCmd returns a new instance which can be used to issue a notifyspent JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deprecated: Use NewLoadTxFilterCmd instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type OutPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type OutPoint struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Hash  string `json:"hash"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Index uint32 `json:"index"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  OutPoint describes a transaction outpoint that will be marshalled to and from JSON.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type PingCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type PingCmd struct{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PingCmd defines the ping JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewPingCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewPingCmd() *PingCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewPingCmd returns a new instance which can be used to issue a ping JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type PreciousBlockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type PreciousBlockCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	BlockHash string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        PreciousBlockCmd defines the preciousblock JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewPreciousBlockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewPreciousBlockCmd(blockHash string) *PreciousBlockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewPreciousBlockCmd returns a new instance which can be used to issue a preciousblock JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PrevOut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PrevOut struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Addresses []string `json:"addresses,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Value     float64  `json:"value"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            PrevOut represents previous output for an input Vin.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RPCError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RPCError struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Code    RPCErrorCode `json:"code,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Message string       `json:"message,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RPCError represents an error that is used as a part of a JSON-RPC Response object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewRPCError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewRPCError(code RPCErrorCode, message string) *RPCError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NewRPCError constructs and returns a new JSON-RPC error that is suitable for use in a JSON-RPC Response object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (RPCError) Error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (e RPCError) Error() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Error returns a string describing the RPC error. This satisifies the builtin error interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RPCErrorCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RPCErrorCode int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RPCErrorCode represents an error code to be used as a part of an RPCError which is in turn used in a JSON-RPC Response object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A specific type is used to help ensure the wrong errors aren't used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ErrRPCMisc                RPCErrorCode = -1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ErrRPCForbiddenBySafeMode RPCErrorCode = -2
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ErrRPCType                RPCErrorCode = -3
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ErrRPCInvalidAddressOrKey RPCErrorCode = -5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ErrRPCOutOfMemory         RPCErrorCode = -7
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ErrRPCInvalidParameter    RPCErrorCode = -8
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ErrRPCDatabase            RPCErrorCode = -20
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ErrRPCDeserialization     RPCErrorCode = -22
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ErrRPCVerify              RPCErrorCode = -25
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ErrRPCInWarmup            RPCErrorCode = -28
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      General application defined JSON errors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ErrRPCClientNotConnected      RPCErrorCode = -9
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ErrRPCClientInInitialDownload RPCErrorCode = -10
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ErrRPCClientNodeNotAdded      RPCErrorCode = -24
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer-to-peer client errors.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ErrRPCWallet                    RPCErrorCode = -4
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ErrRPCWalletInsufficientFunds   RPCErrorCode = -6
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ErrRPCWalletInvalidAccountName  RPCErrorCode = -11
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ErrRPCWalletKeypoolRanOut       RPCErrorCode = -12
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ErrRPCWalletUnlockNeeded        RPCErrorCode = -13
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ErrRPCWalletPassphraseIncorrect RPCErrorCode = -14
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ErrRPCWalletWrongEncState       RPCErrorCode = -15
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ErrRPCWalletEncryptionFailed    RPCErrorCode = -16
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ErrRPCWalletAlreadyUnlocked     RPCErrorCode = -17
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Wallet JSON errors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ErrRPCBlockNotFound     RPCErrorCode = -5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ErrRPCBlockCount        RPCErrorCode = -5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ErrRPCBestBlockHash     RPCErrorCode = -5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ErrRPCDifficulty        RPCErrorCode = -5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ErrRPCOutOfRange        RPCErrorCode = -1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ErrRPCNoTxInfo          RPCErrorCode = -5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ErrRPCNoCFIndex         RPCErrorCode = -5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ErrRPCNoNewestBlockInfo RPCErrorCode = -5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ErrRPCInvalidTxVout     RPCErrorCode = -5
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ErrRPCRawTxString       RPCErrorCode = -32602
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ErrRPCDecodeHexString   RPCErrorCode = -22
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ErrRPCTxError           RPCErrorCode = -25
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ErrRPCTxRejected        RPCErrorCode = -26
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ErrRPCTxAlreadyInChain  RPCErrorCode = -27
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Specific Errors related to commands. These are the ones a user of the RPC server are most likely to see. Generally, the codes should match one of the more general errors above.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ErrRPCNoWallet      RPCErrorCode = -1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ErrRPCUnimplemented RPCErrorCode = -1
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Errors that are specific to btcd.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RawTxInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RawTxInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Txid         string  `json:"txid"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Vout         uint32  `json:"vout"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ScriptPubKey string  `json:"scriptPubKey"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	RedeemScript string  `json:"redeemScript"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Amount       float64 `json:"amount"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                RawTxInput models the data needed for raw transaction input that is used in the SignRawTransactionCmd struct.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ReconsiderBlockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ReconsiderBlockCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	BlockHash string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ReconsiderBlockCmd defines the reconsiderblock JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewReconsiderBlockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewReconsiderBlockCmd(blockHash string) *ReconsiderBlockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewReconsiderBlockCmd returns a new instance which can be used to issue a reconsiderblock JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RecoverAddressesCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RecoverAddressesCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Account string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	N       int
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RecoverAddressesCmd defines the recoveraddresses JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewRecoverAddressesCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewRecoverAddressesCmd(account string, n int) *RecoverAddressesCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewRecoverAddressesCmd returns a new instance which can be used to issue a recoveraddresses JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type RecvTxNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type RecvTxNtfn struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	HexTx string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Block *BlockDetails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          RecvTxNtfn defines the recvtx JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Deprecated: Use RelevantTxAcceptedNtfn and FilteredBlockConnectedNtfn instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewRecvTxNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewRecvTxNtfn(hexTx string, block *BlockDetails) *RecvTxNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewRecvTxNtfn returns a new instance which can be used to issue a recvtx JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deprecated: Use NewRelevantTxAcceptedNtfn and NewFilteredBlockConnectedNtfn instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RedeemingTxNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type RedeemingTxNtfn struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	HexTx string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Block *BlockDetails
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RedeemingTxNtfn defines the redeemingtx JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Deprecated: Use RelevantTxAcceptedNtfn and FilteredBlockConnectedNtfn instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewRedeemingTxNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewRedeemingTxNtfn(hexTx string, block *BlockDetails) *RedeemingTxNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NewRedeemingTxNtfn returns a new instance which can be used to issue a redeemingtx JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deprecated: Use NewRelevantTxAcceptedNtfn and NewFilteredBlockConnectedNtfn instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RelevantTxAcceptedNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type RelevantTxAcceptedNtfn struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Transaction string `json:"transaction"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RelevantTxAcceptedNtfn defines the parameters to the relevanttxaccepted JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewRelevantTxAcceptedNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewRelevantTxAcceptedNtfn(txHex string) *RelevantTxAcceptedNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewRelevantTxAcceptedNtfn returns a new instance which can be used to issue a relevantxaccepted JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RenameAccountCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RenameAccountCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	OldAccount string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	NewAccount string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      RenameAccountCmd defines the renameaccount JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewRenameAccountCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewRenameAccountCmd(oldAccount, newAccount string) *RenameAccountCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewRenameAccountCmd returns a new instance which can be used to issue a renameaccount JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Request

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Request struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Jsonrpc string            `json:"jsonrpc"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Method  string            `json:"method"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Params  []json.RawMessage `json:"params"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ID      interface{}       `json:"id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Request represents raw JSON-RPC requests. The Method field identifies the specific command type which in turn leads to different parameters. Callers typically will not use this directly since this package provides a statically typed command infrastructure which handles creation of these requests, however this struct is being exported in case the caller wants to construct raw requests for some reason.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewRequest(rpcVersion string, id interface{}, method string, params []interface{}) (*Request, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewRequest returns a new JSON-RPC request object given the provided rpc version, id, method, and parameters. The parameters are marshalled into a json.RawMessage for the Params field of the returned request object. This function is only provided in case the caller wants to construct raw requests for some reason. Typically callers will instead want to create a registered concrete command type with the NewCmd or New<Foo>Cmd functions and call the MarshalCmd function with that command to generate the marshalled JSON-RPC request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Request) UnmarshalJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (request *Request) UnmarshalJSON(b []byte) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              UnmarshalJSON is a custom unmarshal func for the Request struct. The param field defaults to an empty json.RawMessage array it is omitted by the request or nil if the supplied value is invalid.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RescanBlocksCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RescanBlocksCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// Block hashes as a string array.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	BlockHashes []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                RescanBlocksCmd defines the rescan JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NOTE: This is a btcd extension ported from github.com/decred/dcrd/dcrjson and requires a websocket connection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewRescanBlocksCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewRescanBlocksCmd(blockHashes []string) *RescanBlocksCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewRescanBlocksCmd returns a new instance which can be used to issue a rescan JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NOTE: This is a btcd extension ported from github.com/decred/dcrd/dcrjson and requires a websocket connection.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RescanCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type RescanCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	BeginBlock string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Addresses  []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	OutPoints  []OutPoint
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	EndBlock   *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RescanCmd defines the rescan JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deprecated: Use RescanBlocksCmd instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewRescanCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewRescanCmd(beginBlock string, addresses []string, outPoints []OutPoint, endBlock *string) *RescanCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewRescanCmd returns a new instance which can be used to issue a rescan JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Deprecated: Use NewRescanBlocksCmd instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RescanFinishedNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RescanFinishedNtfn struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Hash   string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Height int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Time   int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RescanFinishedNtfn defines the rescanfinished JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Deprecated: Not used with rescanblocks command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewRescanFinishedNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewRescanFinishedNtfn(hash string, height int32, time int64) *RescanFinishedNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewRescanFinishedNtfn returns a new instance which can be used to issue a rescanfinished JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Deprecated: Not used with rescanblocks command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RescanProgressNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RescanProgressNtfn struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Hash   string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Height int32
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Time   int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            RescanProgressNtfn defines the rescanprogress JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deprecated: Not used with rescanblocks command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewRescanProgressNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewRescanProgressNtfn(hash string, height int32, time int64) *RescanProgressNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewRescanProgressNtfn returns a new instance which can be used to issue a rescanprogress JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Deprecated: Not used with rescanblocks command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RescannedBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type RescannedBlock struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Hash         string   `json:"hash"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Transactions []string `json:"transactions"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                RescannedBlock contains the hash and all discovered transactions of a single rescanned block.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NOTE: This is a btcsuite extension ported from github.com/decred/dcrd/dcrjson.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Response

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Response struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Jsonrpc string          `json:"jsonrpc"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Result  json.RawMessage `json:"result"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Error   *RPCError       `json:"error"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ID      *interface{}    `json:"id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Response is the general form of a JSON-RPC response. The type of the Result field varies from one command to the next, so it is implemented as an interface. The ID field has to be a pointer to allow for a nil value when empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewResponse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewResponse(rpcVersion string, id interface{}, marshalledResult []byte, rpcErr *RPCError) (*Response, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewResponse returns a new JSON-RPC response object given the provided rpc version, id, marshalled result, and RPC error. This function is only provided in case the caller wants to construct raw responses for some reason. Typically callers will instead want to create the fully marshalled JSON-RPC response to send over the wire with the MarshalResponse function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ScriptPubKeyResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ScriptPubKeyResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Asm       string   `json:"asm"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Hex       string   `json:"hex,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	ReqSigs   int32    `json:"reqSigs,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Type      string   `json:"type"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Addresses []string `json:"addresses,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ScriptPubKeyResult models the scriptPubKey data of a tx script. It is defined separately since it is used by multiple commands.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ScriptSig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ScriptSig struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Asm string `json:"asm"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Hex string `json:"hex"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ScriptSig models a signature script. It is defined separately since it only applies to non-coinbase. Therefore the field in the Vin structure needs to be a pointer.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SearchRawTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SearchRawTransactionsCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Address     string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Verbose     *VerboseLevel `jsonrpcdefault:"1"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Skip        *int          `jsonrpcdefault:"0"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Count       *int          `jsonrpcdefault:"100"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	VinExtra    *int          `jsonrpcdefault:"0"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Reverse     *bool         `jsonrpcdefault:"false"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	FilterAddrs *[]string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SearchRawTransactionsCmd defines the searchrawtransactions JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewSearchRawTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewSearchRawTransactionsCmd(address string, verbose *VerboseLevel, skip, count *int, vinExtra *int, reverse *bool, filterAddrs *[]string) *SearchRawTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewSearchRawTransactionsCmd returns a new instance which can be used to issue a sendrawtransaction JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SearchRawTransactionsResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SearchRawTransactionsResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Hex           string       `json:"hex,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Txid          string       `json:"txid"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Hash          string       `json:"hash"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Size          string       `json:"size"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Vsize         string       `json:"vsize"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Version       int32        `json:"version"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	LockTime      uint32       `json:"locktime"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Vin           []VinPrevOut `json:"vin"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Vout          []Vout       `json:"vout"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	BlockHash     string       `json:"blockhash,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Confirmations uint64       `json:"confirmations,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Time          int64        `json:"time,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Blocktime     int64        `json:"blocktime,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SearchRawTransactionsResult models the data from the searchrawtransaction command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SendFromCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SendFromCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	FromAccount string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	ToAddress   string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Amount      float64 // In BTC
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	MinConf     *int    `jsonrpcdefault:"1"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Comment     *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	CommentTo   *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SendFromCmd defines the sendfrom JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewSendFromCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewSendFromCmd(fromAccount, toAddress string, amount float64, minConf *int, comment, commentTo *string) *SendFromCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewSendFromCmd returns a new instance which can be used to issue a sendfrom JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SendManyCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SendManyCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	FromAccount string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Amounts     map[string]float64 `jsonrpcusage:"{\"address\":amount,...}"` // In BTC
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	MinConf     *int               `jsonrpcdefault:"1"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Comment     *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SendManyCmd defines the sendmany JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewSendManyCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewSendManyCmd(fromAccount string, amounts map[string]float64, minConf *int, comment *string) *SendManyCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewSendManyCmd returns a new instance which can be used to issue a sendmany JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SendRawTransactionCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SendRawTransactionCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	HexTx         string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	AllowHighFees *bool `jsonrpcdefault:"false"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SendRawTransactionCmd defines the sendrawtransaction JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewSendRawTransactionCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewSendRawTransactionCmd(hexTx string, allowHighFees *bool) *SendRawTransactionCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewSendRawTransactionCmd returns a new instance which can be used to issue a sendrawtransaction JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SendToAddressCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SendToAddressCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Address               string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Amount                float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Comment               *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	CommentTo             *string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	SubtractFeeFromAmount *bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SendToAddressCmd defines the sendtoaddress JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewSendToAddressCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewSendToAddressCmd(address string, amount float64, comment, commentTo *string, subtractFeeFromAmount *bool) *SendToAddressCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewSendToAddressCmd returns a new instance which can be used to issue a sendtoaddress JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SessionCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SessionCmd struct{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                SessionCmd defines the session JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewSessionCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewSessionCmd() *SessionCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewSessionCmd returns a new instance which can be used to issue a session JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SessionResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SessionResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	SessionID uint64 `json:"sessionid"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SessionResult models the data from the session command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SetAccountCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SetAccountCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Address string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Account string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SetAccountCmd defines the setaccount JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewSetAccountCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewSetAccountCmd(address, account string) *SetAccountCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewSetAccountCmd returns a new instance which can be used to issue a setaccount JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SetGenerateCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SetGenerateCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Generate     bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	GenProcLimit *int `jsonrpcdefault:"-1"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetGenerateCmd defines the setgenerate JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewSetGenerateCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewSetGenerateCmd(generate bool, genProcLimit *int) *SetGenerateCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewSetGenerateCmd returns a new instance which can be used to issue a setgenerate JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SetTxFeeCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SetTxFeeCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Amount float64 // In BTC
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetTxFeeCmd defines the settxfee JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewSetTxFeeCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewSetTxFeeCmd(amount float64) *SetTxFeeCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NewSetTxFeeCmd returns a new instance which can be used to issue a settxfee JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SignMessageCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SignMessageCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Address string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Message string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SignMessageCmd defines the signmessage JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewSignMessageCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewSignMessageCmd(address, message string) *SignMessageCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewSignMessageCmd returns a new instance which can be used to issue a signmessage JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SignRawTransactionCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SignRawTransactionCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	RawTx    string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Inputs   *[]RawTxInput
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	PrivKeys *[]string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Flags    *string `jsonrpcdefault:"\"ALL\""`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SignRawTransactionCmd defines the signrawtransaction JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewSignRawTransactionCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewSignRawTransactionCmd(hexEncodedTx string, inputs *[]RawTxInput, privKeys *[]string, flags *string) *SignRawTransactionCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewSignRawTransactionCmd returns a new instance which can be used to issue a signrawtransaction JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SignRawTransactionError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SignRawTransactionError struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	TxID      string `json:"txid"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Vout      uint32 `json:"vout"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	ScriptSig string `json:"scriptSig"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Sequence  uint32 `json:"sequence"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Error     string `json:"error"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SignRawTransactionError models the data that contains script verification errors from the signrawtransaction request.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SignRawTransactionResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SignRawTransactionResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Hex      string                    `json:"hex"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Complete bool                      `json:"complete"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Errors   []SignRawTransactionError `json:"errors,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SignRawTransactionResult models the data from the signrawtransaction command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SoftForkDescription

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type SoftForkDescription struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	ID      string `json:"id"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Version uint32 `json:"version"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Reject  struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            		Status bool `json:"status"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	} `json:"reject"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SoftForkDescription describes the current state of a soft-fork which was deployed using a super-majority block signalling.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type StopCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type StopCmd struct{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                StopCmd defines the stop JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewStopCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewStopCmd() *StopCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewStopCmd returns a new instance which can be used to issue a stop JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type StopNotifyBlocksCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type StopNotifyBlocksCmd struct{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    StopNotifyBlocksCmd defines the stopnotifyblocks JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewStopNotifyBlocksCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewStopNotifyBlocksCmd() *StopNotifyBlocksCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewStopNotifyBlocksCmd returns a new instance which can be used to issue a stopnotifyblocks JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type StopNotifyNewTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type StopNotifyNewTransactionsCmd struct{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        StopNotifyNewTransactionsCmd defines the stopnotifynewtransactions JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewStopNotifyNewTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewStopNotifyNewTransactionsCmd() *StopNotifyNewTransactionsCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewStopNotifyNewTransactionsCmd returns a new instance which can be used to issue a stopnotifynewtransactions JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type StopNotifyReceivedCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type StopNotifyReceivedCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Addresses []string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            StopNotifyReceivedCmd defines the stopnotifyreceived JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deprecated: Use LoadTxFilterCmd instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewStopNotifyReceivedCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewStopNotifyReceivedCmd(addresses []string) *StopNotifyReceivedCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewStopNotifyReceivedCmd returns a new instance which can be used to issue a stopnotifyreceived JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Deprecated: Use NewLoadTxFilterCmd instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type StopNotifySpentCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type StopNotifySpentCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	OutPoints []OutPoint
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                StopNotifySpentCmd defines the stopnotifyspent JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Deprecated: Use LoadTxFilterCmd instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewStopNotifySpentCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewStopNotifySpentCmd(outPoints []OutPoint) *StopNotifySpentCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewStopNotifySpentCmd returns a new instance which can be used to issue a stopnotifyspent JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Deprecated: Use NewLoadTxFilterCmd instead.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SubmitBlockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SubmitBlockCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	HexBlock string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Options  *SubmitBlockOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SubmitBlockCmd defines the submitblock JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewSubmitBlockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewSubmitBlockCmd(hexBlock string, options *SubmitBlockOptions) *SubmitBlockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewSubmitBlockCmd returns a new instance which can be used to issue a submitblock JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SubmitBlockOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SubmitBlockOptions struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// must be provided if server provided a workid with template.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	WorkID string `json:"workid,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SubmitBlockOptions represents the optional options struct provided with a SubmitBlockCmd command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TemplateRequest

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TemplateRequest struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Mode         string   `json:"mode,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Capabilities []string `json:"capabilities,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Optional long polling.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	LongPollID string `json:"longpollid,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Optional template tweaking.  SigOpLimit and SizeLimit can be int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// or bool.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SigOpLimit interface{} `json:"sigoplimit,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	SizeLimit  interface{} `json:"sizelimit,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	MaxVersion uint32      `json:"maxversion,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Basic pool extension from BIP 0023.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Target string `json:"target,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// Block proposal from BIP 0023.  Data is only provided when Mode is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	// "proposal".
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Data   string `json:"data,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	WorkID string `json:"workid,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TemplateRequest is a request object as defined in BIP22 (https://en.bitcoin.it/wiki/BIP_0022), it is optionally provided as an pointer argument to GetBlockTemplateCmd.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TemplateRequest) UnmarshalJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TemplateRequest) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            UnmarshalJSON provides a custom Unmarshal method for TemplateRequest. This is necessary because the SigOpLimit and SizeLimit fields can only be specific types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TransactionInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TransactionInput struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Txid string `json:"txid"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Vout uint32 `json:"vout"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TransactionInput represents the inputs to a transaction. Specifically a transaction hash and output number pair.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TxAcceptedNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TxAcceptedNtfn struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	TxID   string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Amount float64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TxAcceptedNtfn defines the txaccepted JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewTxAcceptedNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func NewTxAcceptedNtfn(txHash string, amount float64) *TxAcceptedNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NewTxAcceptedNtfn returns a new instance which can be used to issue a txaccepted JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TxAcceptedVerboseNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TxAcceptedVerboseNtfn struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	RawTx TxRawResult
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TxAcceptedVerboseNtfn defines the txacceptedverbose JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewTxAcceptedVerboseNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func NewTxAcceptedVerboseNtfn(rawTx TxRawResult) *TxAcceptedVerboseNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NewTxAcceptedVerboseNtfn returns a new instance which can be used to issue a txacceptedverbose JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TxRawDecodeResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TxRawDecodeResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Txid     string `json:"txid"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Version  int32  `json:"version"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Locktime uint32 `json:"locktime"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Vin      []Vin  `json:"vin"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Vout     []Vout `json:"vout"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TxRawDecodeResult models the data from the decoderawtransaction command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TxRawResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TxRawResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Hex           string `json:"hex,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Txid          string `json:"txid"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Hash          string `json:"hash,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Size          int32  `json:"size,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Version       int32  `json:"version"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	LockTime      uint32 `json:"locktime"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Vin           []Vin  `json:"vin"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Vout          []Vout `json:"vout"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	BlockHash     string `json:"blockhash,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Confirmations uint64 `json:"confirmations,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Time          int64  `json:"time,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Blocktime     int64  `json:"blocktime,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TxRawResult models the data from the getrawtransaction command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type UptimeCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type UptimeCmd struct{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            UptimeCmd defines the uptime JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewUptimeCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func NewUptimeCmd() *UptimeCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NewUptimeCmd returns a new instance which can be used to issue an uptime JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type UsageFlag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type UsageFlag uint32

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UsageFlag define flags that specify additional properties about the circumstances under which a command can be used.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// UFWalletOnly indicates that the command can only be used with an RPC
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// server that supports wallet commands.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	UFWalletOnly UsageFlag = 1 << iota
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// UFWebsocketOnly indicates that the command can only be used when
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// communicating with an RPC server over websockets.  This typically
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// applies to notifications and notification registration functions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// since neiher makes since when using a single-shot HTTP-POST request.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	UFWebsocketOnly
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// UFNotification indicates that the command is actually a notification.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// This means when it is marshalled, the ID must be nil.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	UFNotification
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func MethodUsageFlags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func MethodUsageFlags(method string) (UsageFlag, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MethodUsageFlags returns the usage flags for the passed command method. The provided method must be associated with a registered type. All commands provided by this package are registered by default.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (UsageFlag) String

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (fl UsageFlag) String() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    String returns the UsageFlag in human-readable form.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ValidateAddressChainResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ValidateAddressChainResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	IsValid bool   `json:"isvalid"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	Address string `json:"address,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ValidateAddressChainResult models the data returned by the chain server validateaddress command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ValidateAddressCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ValidateAddressCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Address string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ValidateAddressCmd defines the validateaddress JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewValidateAddressCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func NewValidateAddressCmd(address string) *ValidateAddressCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NewValidateAddressCmd returns a new instance which can be used to issue a validateaddress JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ValidateAddressWalletResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type ValidateAddressWalletResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	IsValid      bool     `json:"isvalid"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Address      string   `json:"address,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	IsMine       bool     `json:"ismine,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	IsWatchOnly  bool     `json:"iswatchonly,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	IsScript     bool     `json:"isscript,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	PubKey       string   `json:"pubkey,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	IsCompressed bool     `json:"iscompressed,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Account      string   `json:"account,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Addresses    []string `json:"addresses,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Hex          string   `json:"hex,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Script       string   `json:"script,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	SigsRequired int32    `json:"sigsrequired,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ValidateAddressWalletResult models the data returned by the wallet server validateaddress command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type VerboseLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type VerboseLevel int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              VerboseLevel is a type that can unmarshal a bool or an int into an int field! This allows the raw API to receive either an int or a bool.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func Verboselevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func Verboselevel(v VerboseLevel) *VerboseLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Verboselevel is a helper routine that allocates a new VerbosityLevel value to store v and returns a pointer to it. This is useful when assigning optional parameters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*VerboseLevel) UnmarshalJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (v *VerboseLevel) UnmarshalJSON(dat []byte) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  UnmarshalJSON allows the VerbosityLevel to unmarshal either bool or int.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type VerbosityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type VerbosityLevel int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    VerbosityLevel is a type that can unmarshal a bool or an int into an int field! This allows the raw API to receive either an int or a bool.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func Verbositylevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func Verbositylevel(v VerbosityLevel) *VerbosityLevel

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Verbositylevel is a helper routine that allocates a new VerbosityLevel value to store v and returns a pointer to it. This is useful when assigning optional parameters.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*VerbosityLevel) UnmarshalJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (v *VerbosityLevel) UnmarshalJSON(dat []byte) error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        UnmarshalJSON allows the VerbosityLevel to unmarshal either bool or int.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type VerifyChainCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type VerifyChainCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CheckLevel *int32 `jsonrpcdefault:"3"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	CheckDepth *int32 `jsonrpcdefault:"288"` // 0 = all
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          VerifyChainCmd defines the verifychain JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewVerifyChainCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewVerifyChainCmd(checkLevel, checkDepth *int32) *VerifyChainCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewVerifyChainCmd returns a new instance which can be used to issue a verifychain JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type VerifyMessageCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type VerifyMessageCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Address   string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Signature string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Message   string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              VerifyMessageCmd defines the verifymessage JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewVerifyMessageCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewVerifyMessageCmd(address, signature, message string) *VerifyMessageCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NewVerifyMessageCmd returns a new instance which can be used to issue a verifymessage JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type VerifyTxOutProofCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type VerifyTxOutProofCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Proof string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  VerifyTxOutProofCmd defines the verifytxoutproof JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewVerifyTxOutProofCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewVerifyTxOutProofCmd(proof string) *VerifyTxOutProofCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewVerifyTxOutProofCmd returns a new instance which can be used to issue a verifytxoutproof JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type VersionCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type VersionCmd struct{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      VersionCmd defines the version JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NOTE: This is a btcsuite extension ported from github.com/decred/dcrd/dcrjson.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewVersionCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewVersionCmd() *VersionCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewVersionCmd returns a new instance which can be used to issue a JSON-RPC version command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NOTE: This is a btcsuite extension ported from github.com/decred/dcrd/dcrjson.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type VersionResult

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type VersionResult struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	VersionString string `json:"versionstring"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Major         uint32 `json:"major"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Minor         uint32 `json:"minor"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Patch         uint32 `json:"patch"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Prerelease    string `json:"prerelease"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	BuildMetadata string `json:"buildmetadata"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          VersionResult models objects included in the version response. In the actual result, these objects are keyed by the program or API name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NOTE: This is a btcsuite extension ported from github.com/decred/dcrd/dcrjson.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Vin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Vin struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Coinbase  string     `json:"coinbase"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Txid      string     `json:"txid"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Vout      uint32     `json:"vout"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ScriptSig *ScriptSig `json:"scriptSig"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	Sequence  uint32     `json:"sequence"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Vin models parts of the tx data. It is defined separately since getrawtransaction, decoderawtransaction, and searchrawtransaction use the same structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Vin) IsCoinBase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (v *Vin) IsCoinBase() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              IsCoinBase returns a bool to show if a Vin is a Coinbase one or not.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Vin) MarshalJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (v *Vin) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                MarshalJSON provides a custom Marshal method for Vin.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type VinPrevOut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type VinPrevOut struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Coinbase  string     `json:"coinbase"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Txid      string     `json:"txid"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Vout      uint32     `json:"vout"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	ScriptSig *ScriptSig `json:"scriptSig"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	PrevOut   *PrevOut   `json:"prevOut"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Sequence  uint32     `json:"sequence"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  VinPrevOut is like Vin except it includes PrevOut. It is used by searchrawtransaction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*VinPrevOut) IsCoinBase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (v *VinPrevOut) IsCoinBase() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    IsCoinBase returns a bool to show if a Vin is a Coinbase one or not.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*VinPrevOut) MarshalJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (v *VinPrevOut) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MarshalJSON provides a custom Marshal method for VinPrevOut.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Vout

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Vout struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	Value        float64            `json:"value"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	N            uint32             `json:"n"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	ScriptPubKey ScriptPubKeyResult `json:"scriptPubKey"`
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Vout models parts of the tx data. It is defined separately since both getrawtransaction and decoderawtransaction use the same structure.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type WalletIsLockedCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type WalletIsLockedCmd struct{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          WalletIsLockedCmd defines the walletislocked JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewWalletIsLockedCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewWalletIsLockedCmd() *WalletIsLockedCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewWalletIsLockedCmd returns a new instance which can be used to issue a walletislocked JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type WalletLockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type WalletLockCmd struct{}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              WalletLockCmd defines the walletlock JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewWalletLockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func NewWalletLockCmd() *WalletLockCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NewWalletLockCmd returns a new instance which can be used to issue a walletlock JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type WalletLockStateNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type WalletLockStateNtfn struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Locked bool
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  WalletLockStateNtfn defines the walletlockstate JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewWalletLockStateNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func NewWalletLockStateNtfn(locked bool) *WalletLockStateNtfn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NewWalletLockStateNtfn returns a new instance which can be used to issue a walletlockstate JSON-RPC notification.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type WalletPassphraseChangeCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type WalletPassphraseChangeCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	OldPassphrase string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	NewPassphrase string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      WalletPassphraseChangeCmd defines the walletpassphrase JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewWalletPassphraseChangeCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func NewWalletPassphraseChangeCmd(oldPassphrase, newPassphrase string) *WalletPassphraseChangeCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NewWalletPassphraseChangeCmd returns a new instance which can be used to issue a walletpassphrasechange JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type WalletPassphraseCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type WalletPassphraseCmd struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Passphrase string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	Timeout    int64
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          WalletPassphraseCmd defines the walletpassphrase JSON-RPC command.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewWalletPassphraseCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func NewWalletPassphraseCmd(passphrase string, timeout int64) *WalletPassphraseCmd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NewWalletPassphraseCmd returns a new instance which can be used to issue a walletpassphrase JSON-RPC command.