Documentation ¶
Overview ¶
Package hcashjson provides primitives for working with the hypercash 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:
- Unmarshal the raw bytes into a Request struct instance via json.Unmarshal
- 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:
- Unmarhsal the raw bytes into a Response struct instance via json.Unmarshal
- 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 *hcashjson.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.
package main import ( "encoding/json" "fmt" "github.com/HcashOrg/hcashd/hcashjson" ) func main() { // Ordinarily this would be read from the wire, but for this example, // it is hard coded here for clarity. This is an example response to a // getblockheight request. data := []byte(`{"result":350001,"error":null,"id":1}`) // Unmarshal the raw bytes from the wire into a JSON-RPC response. var response hcashjson.Response if err := json.Unmarshal(data, &response); err != nil { fmt.Println("Malformed JSON-RPC response:", err) return } // Check the response for an error from the server. For example, the // server might return an error if an invalid/unknown block hash is // requested. if response.Error != nil { fmt.Println(response.Error) return } // Unmarshal the result into the expected type for the response. var blockHeight int32 if err := json.Unmarshal(response.Result, &blockHeight); err != nil { fmt.Printf("Unexpected result type: %T\n", response.Result) return } fmt.Println("Block height:", blockHeight) }
Output: Block height: 350001
Index ¶
- Constants
- Variables
- func Bool(v bool) *bool
- func CmdMethod(cmd interface{}) (string, error)
- func DecodeConcatenatedHashes(hashes string) ([]chainhash.Hash, error)
- func DecodeConcatenatedVoteBits(voteBitsString string) ([]stake.VoteBits, error)
- func EncodeConcatenatedHashes(hashSlice []chainhash.Hash) string
- func EncodeConcatenatedVoteBits(voteBitsSlice []stake.VoteBits) (string, error)
- func Float64(v float64) *float64
- func GenerateHelp(method string, descs map[string]string, resultTypes ...interface{}) (string, error)
- func Int(v int) *int
- func Int32(v int32) *int32
- func Int64(v int64) *int64
- func IsValidIDType(id interface{}) bool
- func MarshalCmd(id interface{}, cmd interface{}) ([]byte, error)
- func MarshalResponse(id interface{}, result interface{}, rpcErr *RPCError) ([]byte, error)
- func MethodUsageText(method string) (string, error)
- func MustRegisterCmd(method string, cmd interface{}, flags UsageFlag)
- func NewCmd(method string, args ...interface{}) (interface{}, error)
- func RegisterCmd(method string, cmd interface{}, flags UsageFlag) error
- func RegisteredCmdMethods() []string
- func String(v string) *string
- func Uint(v uint) *uint
- func Uint32(v uint32) *uint32
- func Uint64(v uint64) *uint64
- func UnmarshalCmd(r *Request) (interface{}, error)
- type AccountAddressIndexCmd
- type AccountBalanceNtfn
- type AccountSyncAddressIndexCmd
- type AddMultisigAddressCmd
- type AddNodeCmd
- type AddNodeSubCmd
- type AddTicketCmd
- type Agenda
- type AuthenticateCmd
- type BlockConnectedNtfn
- type BlockDisconnectedNtfn
- type BtcdConnectedNtfn
- type CalcPowSubsidyCmd
- type Choice
- type ConsolidateCmd
- type CreateEncryptedWalletCmd
- type CreateMultiSigResult
- type CreateMultisigCmd
- type CreateNewAccountCmd
- type CreateRawSSGenTxCmd
- type CreateRawSSRtxCmd
- type CreateRawSStxCmd
- type CreateRawTransactionCmd
- type DebugLevelCmd
- type DecodeRawTransactionCmd
- type DecodeScriptCmd
- type DecodeScriptResult
- type DumpPrivKeyCmd
- type Error
- type ErrorCode
- type EstimateFeeCmd
- type EstimatePriorityCmd
- type EstimateStakeDiffCmd
- type EstimateStakeDiffResult
- type ExistsAddressCmd
- type ExistsAddressesCmd
- type ExistsExpiredTicketsCmd
- type ExistsLiveTicketCmd
- type ExistsLiveTicketsCmd
- type ExistsMempoolTxsCmd
- type ExistsMissedTicketsCmd
- type ExportWatchingWalletCmd
- type FeeInfoBlock
- type FeeInfoMempool
- type FeeInfoRange
- type FeeInfoWindow
- type GenerateCmd
- type GenerateVoteCmd
- type GenerateVoteResult
- type GetAccountAddressCmd
- type GetAccountBalanceResult
- type GetAccountCmd
- type GetAddedNodeInfoCmd
- type GetAddedNodeInfoResult
- type GetAddedNodeInfoResultAddr
- type GetAddressesByAccountCmd
- type GetBalanceCmd
- type GetBalanceResult
- type GetBestBlockCmd
- type GetBestBlockHashCmd
- type GetBestBlockResult
- type GetBlockChainInfoCmd
- type GetBlockChainInfoResult
- type GetBlockCmd
- type GetBlockCountCmd
- type GetBlockHashCmd
- type GetBlockHeaderCmd
- type GetBlockHeaderVerboseResult
- type GetBlockKeyHeightCmd
- type GetBlockSubsidyCmd
- type GetBlockSubsidyResult
- type GetBlockTemplateCmd
- type GetBlockTemplateResult
- type GetBlockTemplateResultAux
- type GetBlockTemplateResultTx
- type GetBlockVerboseResult
- type GetChainTipsCmd
- type GetCoinSupplyCmd
- type GetConnectionCountCmd
- type GetCurrentNetCmd
- type GetDifficultyCmd
- type GetGenerateCmd
- type GetHashesPerSecCmd
- type GetHeadersCmd
- type GetHeadersResult
- type GetInfoCmd
- type GetKeyBlockHashCmd
- type GetMasterPubkeyCmd
- type GetMempoolInfoCmd
- type GetMempoolInfoResult
- type GetMiningInfoCmd
- type GetMiningInfoResult
- type GetMultisigOutInfoCmd
- type GetMultisigOutInfoResult
- type GetNetTotalsCmd
- type GetNetTotalsResult
- type GetNetworkHashPSCmd
- type GetNetworkInfoCmd
- type GetNetworkInfoResult
- type GetNewAddressCmd
- type GetPeerInfoCmd
- type GetPeerInfoResult
- type GetRawChangeAddressCmd
- type GetRawMempoolCmd
- type GetRawMempoolTxTypeCmd
- type GetRawMempoolVerboseResult
- type GetRawTransactionCmd
- type GetReceivedByAccountCmd
- type GetReceivedByAddressCmd
- type GetSeedCmd
- type GetStakeDifficultyCmd
- type GetStakeDifficultyResult
- type GetStakeInfoCmd
- type GetStakeInfoResult
- type GetStakeVersionInfoCmd
- type GetStakeVersionInfoResult
- type GetStakeVersionsCmd
- type GetStakeVersionsResult
- type GetTicketFeeCmd
- type GetTicketPoolValueCmd
- type GetTicketsCmd
- type GetTicketsResult
- type GetTransactionCmd
- type GetTransactionDetailsResult
- type GetTransactionResult
- type GetTxOutCmd
- type GetTxOutResult
- type GetTxOutSetInfoCmd
- type GetUnconfirmedBalanceCmd
- type GetVoteChoicesCmd
- type GetVoteChoicesResult
- type GetVoteInfoCmd
- type GetVoteInfoResult
- type GetWalletFeeCmd
- type GetWorkCmd
- type GetWorkResult
- type HelpCmd
- type ImportAddressCmd
- type ImportPrivKeyCmd
- type ImportPubKeyCmd
- type ImportScriptCmd
- type InfoChainResult
- type InfoWalletResult
- type KeyPoolRefillCmd
- type ListAccountsCmd
- type ListAddressTransactionsCmd
- type ListAllTransactionsCmd
- type ListLockUnspentCmd
- type ListReceivedByAccountCmd
- type ListReceivedByAccountResult
- type ListReceivedByAddressCmd
- type ListReceivedByAddressResult
- type ListScriptsCmd
- type ListScriptsResult
- type ListSinceBlockCmd
- type ListSinceBlockResult
- type ListTransactionsCmd
- type ListTransactionsResult
- type ListTransactionsTxType
- type ListTxsCmd
- type ListTxsElem
- type ListTxsResult
- type ListUnspentCmd
- type ListUnspentResult
- type LiveTicket
- type LiveTicketsCmd
- type LiveTicketsResult
- type LoadTxFilterCmd
- type LocalAddressesResult
- type LockUnspentCmd
- type MissedTicketsCmd
- type MissedTicketsResult
- type NetworksResult
- type NewTicketsNtfn
- type NewTxNtfn
- type NodeCmd
- type NodeSubCmd
- type NotifyBlocksCmd
- type NotifyNewTicketsCmd
- type NotifyNewTransactionsCmd
- type NotifySpentAndMissedTicketsCmd
- type NotifyStakeDifficultyCmd
- type NotifyWinningTicketsCmd
- type OutPoint
- type PingCmd
- type PoolUserTicket
- type PrevOut
- type PurchaseTicketCmd
- type RPCError
- type RPCErrorCode
- type RawTxInput
- type RebroadcastMissedCmd
- type RebroadcastWinnersCmd
- type RecoverAddressesCmd
- type RedeemMultiSigOutCmd
- type RedeemMultiSigOutResult
- type RedeemMultiSigOutsCmd
- type RedeemMultiSigOutsResult
- type RelevantTxAcceptedNtfn
- type RenameAccountCmd
- type ReorganizationNtfn
- type Request
- type RescanCmd
- type RescanResult
- type RescanWalletCmd
- type RescannedBlock
- type Response
- type RevocationCreatedNtfn
- type RevokeTicketsCmd
- type SStxCommitOut
- type SStxInput
- type ScriptInfo
- type ScriptPubKeyResult
- type ScriptSig
- type SearchRawTransactionsCmd
- type SearchRawTransactionsResult
- type SendFromCmd
- type SendManyCmd
- type SendRawTransactionCmd
- type SendToAddressCmd
- type SendToMultiSigCmd
- type SendToMultiSigResult
- type SendToSSGenCmd
- type SendToSSRtxCmd
- type SendToSStxCmd
- type SessionCmd
- type SessionResult
- type SetBalanceToMaintainCmd
- type SetGenerateCmd
- type SetTicketFeeCmd
- type SetTicketMaxPriceCmd
- type SetTxFeeCmd
- type SetVoteChoiceCmd
- type SignMessageCmd
- type SignRawTransactionCmd
- type SignRawTransactionError
- type SignRawTransactionResult
- type SignRawTransactionsCmd
- type SignRawTransactionsResult
- type SignedTransaction
- type SpentAndMissedTicketsNtfn
- type StakeDifficultyNtfn
- type StakePoolUserInfoCmd
- type StakePoolUserInfoResult
- type StakeVersions
- type StopCmd
- type StopNotifyBlocksCmd
- type StopNotifyNewTransactionsCmd
- type SubmitBlockCmd
- type SubmitBlockOptions
- type TemplateRequest
- type Ticket
- type TicketFeeInfoCmd
- type TicketFeeInfoResult
- type TicketPurchasedNtfn
- type TicketVWAPCmd
- type TicketsForAddressCmd
- type TicketsForAddressResult
- type TransactionInput
- type TxAcceptedNtfn
- type TxAcceptedVerboseNtfn
- type TxFeeInfoCmd
- type TxFeeInfoResult
- type TxRawDecodeResult
- type TxRawResult
- type UsageFlag
- type ValidateAddressChainResult
- type ValidateAddressCmd
- type ValidateAddressWalletResult
- type VerifyChainCmd
- type VerifyMessageCmd
- type VersionBits
- type VersionCmd
- type VersionCount
- type VersionInterval
- type VersionResult
- type Vin
- type VinPrevOut
- type VoteChoice
- type VoteCreatedNtfn
- type Vout
- type WalletInfoCmd
- type WalletInfoResult
- type WalletIsLockedCmd
- type WalletLockCmd
- type WalletLockStateNtfn
- type WalletPassphraseChangeCmd
- type WalletPassphraseCmd
- type WinningTicketsNtfn
Examples ¶
Constants ¶
const ( // BlockConnectedNtfnMethod is the method used for notifications from // the chain server that a block has been connected. BlockConnectedNtfnMethod = "blockconnected" // BlockDisconnectedNtfnMethod is the method used for notifications from // the chain server that a block has been disconnected. BlockDisconnectedNtfnMethod = "blockdisconnected" // ReorganizationNtfnMethod is the method used for notifications that the // block chain is in the process of a reorganization. ReorganizationNtfnMethod = "reorganization" // 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 method used for notifications // from the chain server that inform a client that a relevant // transaction was accepted by the mempool. RelevantTxAcceptedNtfnMethod = "relevanttxaccepted" )
const ( // TicketPurchasedNtfnMethod is the method of the hcashwallet // ticketpurchased notification. TicketPurchasedNtfnMethod = "ticketpurchased" // VoteCreatedNtfnMethod is the method of the hcashwallet // votecreated notification. VoteCreatedNtfnMethod = "votecreated" // RevocationCreatedNtfnMethod is the method of the hcashwallet // revocationcreated notification. RevocationCreatedNtfnMethod = "revocationcreated" // WinningTicketsNtfnMethod is the method of the daemon // winningtickets notification. WinningTicketsNtfnMethod = "winningtickets" // SpentAndMissedTicketsNtfnMethod is the method of the daemon // spentandmissedtickets notification. SpentAndMissedTicketsNtfnMethod = "spentandmissedtickets" // NewTicketsNtfnMethod is the method of the daemon // newtickets notification. NewTicketsNtfnMethod = "newtickets" // StakeDifficultyNtfnMethod is the method of the daemon // stakedifficulty notification. StakeDifficultyNtfnMethod = "stakedifficulty" )
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 = "hcashdconnected" // 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 transaciton store. NewTxNtfnMethod = "newtx" )
Variables ¶
var ( ErrInvalidRequest = Error{ Code: -32600, Message: "Invalid request", } ErrMethodNotFound = Error{ Code: -32601, Message: "Method not found", } ErrInvalidParams = Error{ Code: -32602, Message: "Invalid paramaters", } ErrInternal = Error{ Code: -32603, Message: "Internal error", } ErrParse = Error{ Code: -32700, Message: "Parse error", } )
Standard JSON-RPC 2.0 errors
var ( ErrMisc = Error{ Code: -1, Message: "Miscellaneous error", } ErrForbiddenBySafeMode = Error{ Code: -2, Message: "Server is in safe mode, and command is not allowed in safe mode", } ErrType = Error{ Code: -3, Message: "Unexpected type was passed as parameter", } ErrInvalidAddressOrKey = Error{ Code: -5, Message: "Invalid address or key", } ErrOutOfMemory = Error{ Code: -7, Message: "Ran out of memory during operation", } ErrInvalidParameter = Error{ Code: -8, Message: "Invalid, missing or duplicate parameter", } ErrDatabase = Error{ Code: -20, Message: "Database error", } ErrDeserialization = Error{ Code: -22, Message: "Error parsing or validating structure in raw format", } )
General application defined JSON errors
var ( ErrClientNotConnected = Error{ Code: -9, Message: "hcashd is not connected", } ErrClientInInitialDownload = Error{ Code: -10, Message: "hcashd is downloading blocks...", } )
Peer-to-peer client errors
var ( ErrWallet = Error{ Code: -4, Message: "Unspecified problem with wallet", } ErrWalletInsufficientFunds = Error{ Code: -6, Message: "Not enough funds in wallet or account", } ErrWalletInvalidAccountName = Error{ Code: -11, Message: "Invalid account name", } ErrWalletKeypoolRanOut = Error{ Code: -12, Message: "Keypool ran out, call keypoolrefill first", } ErrWalletUnlockNeeded = Error{ Code: -13, Message: "Enter the wallet passphrase with walletpassphrase first", } ErrWalletPassphraseIncorrect = Error{ Code: -14, Message: "The wallet passphrase entered was incorrect", } ErrWalletWrongEncState = Error{ Code: -15, Message: "Command given in wrong wallet encryption state", } ErrWalletEncryptionFailed = Error{ Code: -16, Message: "Failed to encrypt the wallet", } ErrWalletAlreadyUnlocked = Error{ Code: -17, Message: "Wallet is already unlocked", } )
Wallet JSON errors
var ( ErrBlockNotFound = Error{ Code: -5, Message: "Block not found", } ErrBlockCount = Error{ Code: -5, Message: "Error getting block count", } ErrBestBlockHash = Error{ Code: -5, Message: "Error getting best block hash", } ErrDifficulty = Error{ Code: -5, Message: "Error getting difficulty", } ErrOutOfRange = Error{ Code: -1, Message: "Block number out of range", } ErrNoTxInfo = Error{ Code: -5, Message: "No information available about transaction", } ErrNoNewestBlockInfo = Error{ Code: -5, Message: "No information about newest block", } ErrInvalidTxVout = Error{ Code: -5, Message: "Ouput index number (vout) does not exist for transaction.", } ErrRawTxString = Error{ Code: -32602, Message: "Raw tx is not a string", } ErrDecodeHexString = Error{ Code: -22, Message: "Unable to decode hex string", } )
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.
var ( ErrNoWallet = Error{ Code: -1, Message: "This implementation does not implement wallet commands", } ErrUnimplemented = Error{ Code: -1, Message: "Command unimplemented", } )
Errors that are specific to hcashd.
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 ¶
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 ¶
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 DecodeConcatenatedHashes ¶
DecodeConcatenatedHashes return a slice of contiguous chainhash.Hash objects created by decoding a single string of concatenated hex-encoded hashes.
These hashes must NOT be the byte reversed string encoding that is typically used for block and transaction hashes, or each resulting hash will also be reversed.
The length of the string must be evenly divisible by twice the hash size in order for the parameter to be valid. This function assumes the input is from a JSON-RPC request and any errors will be of type *RPCError with an ErrRPCInvalidParameter or ErrRPCDecodedHexString error code.
func DecodeConcatenatedVoteBits ¶
DecodeConcatenatedVoteBits decodes a string encoded as a slice of concatenated voteBits and extended voteBits, and returns the slice of DecodedVoteBits to the caller.
func EncodeConcatenatedHashes ¶
EncodeConcatenatedHashes serializes a slice of chainhash.Hash values into a string of hex-encoded bytes.
func EncodeConcatenatedVoteBits ¶
EncodeConcatenatedVoteBits encodes a slice of VoteBits into a serialized byte slice. The entirety of the voteBits are encoded individually in series as follows:
Size Description 1 byte Length of the concatenated voteBits in bytes 2 bytes Vote bits up to 73 bytes Extended vote bits
The result may be concatenated into a slice and then passed to callers
func 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 ¶
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 ¶
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 ¶
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 ¶
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.
package main import ( "fmt" "github.com/HcashOrg/hcashd/hcashjson" ) func main() { // Create a new getblock command. Notice the nil parameter indicates // to use the default parameter for that fields. This is a common // pattern used in all of the New<Foo>Cmd functions in this package for // optional fields. Also, notice the call to hcashjson.Bool which is a // convenience function for creating a pointer out of a primitive for // optional parameters. blockHash := "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f" gbCmd := hcashjson.NewGetBlockCmd(blockHash, hcashjson.Bool(false), nil) // Marshal the command to the format suitable for sending to the RPC // server. Typically the client would increment the id here which is // request so the response can be identified. id := 1 marshalledBytes, err := hcashjson.MarshalCmd(id, gbCmd) if err != nil { fmt.Println(err) return } // Display the marshalled command. Ordinarily this would be sent across // the wire to the RPC server, but for this example, just display it. fmt.Printf("%s\n", marshalledBytes) }
Output: {"jsonrpc":"1.0","method":"getblock","params":["000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",false],"id":1}
func MarshalResponse ¶
MarshalResponse marshals the passed 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.
package main import ( "fmt" "github.com/HcashOrg/hcashd/hcashjson" ) func main() { // Marshal a new JSON-RPC response. For example, this is a response // to a getblockheight request. marshalledBytes, err := hcashjson.MarshalResponse(1, 350001, nil) if err != nil { fmt.Println(err) return } // Display the marshalled response. Ordinarily this would be sent // across the wire to the RPC client, but for this example, just display // it. fmt.Printf("%s\n", marshalledBytes) }
Output: {"result":350001,"error":null,"id":1}
func MethodUsageText ¶
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 ¶
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 ¶
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 ¶
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 ¶
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 ¶
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 ¶
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 ¶
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 ¶
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.
package main import ( "encoding/json" "fmt" "github.com/HcashOrg/hcashd/hcashjson" ) func main() { // Ordinarily this would be read from the wire, but for this example, // it is hard coded here for clarity. data := []byte(`{"jsonrpc":"1.0","method":"getblock","params":["000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f",false],"id":1}`) // Unmarshal the raw bytes from the wire into a JSON-RPC request. var request hcashjson.Request if err := json.Unmarshal(data, &request); err != nil { fmt.Println(err) return } // Typically there isn't any need to examine the request fields directly // like this as the caller already knows what response to expect based // on the command it sent. However, this is done here to demonstrate // why the unmarshal process is two steps. if request.ID == nil { fmt.Println("Unexpected notification") return } if request.Method != "getblock" { fmt.Println("Unexpected method") return } // Unmarshal the request into a concrete command. cmd, err := hcashjson.UnmarshalCmd(&request) if err != nil { fmt.Println(err) return } // Type assert the command to the appropriate type. gbCmd, ok := cmd.(*hcashjson.GetBlockCmd) if !ok { fmt.Printf("Incorrect command type: %T\n", cmd) return } // Display the fields in the concrete command. fmt.Println("Hash:", gbCmd.Hash) fmt.Println("Verbose:", *gbCmd.Verbose) fmt.Println("VerboseTx:", *gbCmd.VerboseTx) }
Output: Hash: 000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f Verbose: false VerboseTx: false
Types ¶
type AccountAddressIndexCmd ¶
AccountAddressIndexCmd is a type handling custom marshaling and unmarshaling of accountaddressindex JSON wallet extension commands.
func NewAccountAddressIndexCmd ¶
func NewAccountAddressIndexCmd(acct string, branch int) *AccountAddressIndexCmd
NewAccountAddressIndexCmd creates a new AccountAddressIndexCmd.
type AccountBalanceNtfn ¶
type AccountBalanceNtfn struct { Account string Balance float64 // In HCASH 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 AccountSyncAddressIndexCmd ¶
type AccountSyncAddressIndexCmd struct { Account string `json:"account"` Branch int `json:"branch"` Index int `json:"index"` }
AccountSyncAddressIndexCmd is a type handling custom marshaling and unmarshaling of accountsyncaddressindex JSON wallet extension commands.
func NewAccountSyncAddressIndexCmd ¶
func NewAccountSyncAddressIndexCmd(acct string, branch int, idx int) *AccountSyncAddressIndexCmd
NewAccountSyncAddressIndexCmd creates a new AccountSyncAddressIndexCmd.
type AddMultisigAddressCmd ¶
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 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 AddTicketCmd ¶
type AddTicketCmd struct {
TicketHex string `json:"tickethex"`
}
AddTicketCmd forces a ticket into the wallet stake manager, for example if someone made an invalid ticket for a stake pool and the pool manager wanted to manually add it.
func NewAddTicketCmd ¶
func NewAddTicketCmd(ticketHex string) *AddTicketCmd
NewAddTicketCmd creates a new AddTicketCmd.
type Agenda ¶
type Agenda struct { Id string `json:"id"` Description string `json:"description"` Mask uint16 `json:"mask"` StartTime uint64 `json:"starttime"` ExpireTime uint64 `json:"expiretime"` Status string `json:"status"` QuorumProgress float64 `json:"quorumprogress"` Choices []Choice `json:"choices"` }
Agenda models an individual agenda including its choices.
type AuthenticateCmd ¶
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 BlockConnectedNtfn ¶
type BlockConnectedNtfn struct { Header string `json:"header"` SubscribedTxs []string `json:"subscribedtxs"` }
BlockConnectedNtfn defines the blockconnected JSON-RPC notification.
func NewBlockConnectedNtfn ¶
func NewBlockConnectedNtfn(header string, subscribedTxs []string) *BlockConnectedNtfn
NewBlockConnectedNtfn returns a new instance which can be used to issue a blockconnected JSON-RPC notification.
type BlockDisconnectedNtfn ¶
type BlockDisconnectedNtfn struct {
Header string `json:"header"`
}
BlockDisconnectedNtfn defines the blockdisconnected JSON-RPC notification.
func NewBlockDisconnectedNtfn ¶
func NewBlockDisconnectedNtfn(header string) *BlockDisconnectedNtfn
NewBlockDisconnectedNtfn returns a new instance which can be used to issue a blockdisconnected JSON-RPC notification.
type BtcdConnectedNtfn ¶
type BtcdConnectedNtfn struct {
Connected bool
}
BtcdConnectedNtfn defines the hcashddconnected JSON-RPC notification.
func NewBtcdConnectedNtfn ¶
func NewBtcdConnectedNtfn(connected bool) *BtcdConnectedNtfn
NewBtcdConnectedNtfn returns a new instance which can be used to issue a hcashddconnected JSON-RPC notification.
type CalcPowSubsidyCmd ¶
type CalcPowSubsidyCmd struct { Account *string From *int `jsonrpcdefault:"0"` Count *int `jsonrpcdefault:"0"` IncludeWatchOnly *bool `jsonrpcdefault:"false"` }
func NewCalcPowSubsidyCmd ¶
func NewCalcPowSubsidyCmd(account *string, count, from *int, includeWatchOnly *bool) *CalcPowSubsidyCmd
NewListTxsCmd returns a new instance which can be used to issue a listtxs JSON-RPC command.
The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.
type Choice ¶
type Choice struct { Id string `json:"id"` Description string `json:"description"` Bits uint16 `json:"bits"` IsAbstain bool `json:"isabstain"` IsNo bool `json:"isno"` Count uint32 `json:"count"` Progress float64 `json:"progress"` }
Choice models an individual choice inside an Agenda.
type ConsolidateCmd ¶
ConsolidateCmd is a type handling custom marshaling and unmarshaling of consolidate JSON wallet extension commands.
func NewConsolidateCmd ¶
func NewConsolidateCmd(inputs int, acct *string, addr *string) *ConsolidateCmd
NewConsolidateCmd creates a new ConsolidateCmd.
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 ¶
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 ¶
CreateNewAccountCmd defines the createnewaccount JSON-RPC command.
func NewCreateNewAccountCmd ¶
func NewCreateNewAccountCmd(account string, acctype string) *CreateNewAccountCmd
NewCreateNewAccountCmd returns a new instance which can be used to issue a createnewaccount JSON-RPC command.
type CreateRawSSGenTxCmd ¶
type CreateRawSSGenTxCmd struct { Inputs []TransactionInput VoteBits uint16 }
CreateRawSSGenTxCmd is a type handling custom marshaling and unmarshaling of createrawssgentxcmd JSON RPC commands.
func NewCreateRawSSGenTxCmd ¶
func NewCreateRawSSGenTxCmd(inputs []TransactionInput, vb uint16) *CreateRawSSGenTxCmd
NewCreateRawSSGenTxCmd creates a new CreateRawSSGenTxCmd.
type CreateRawSSRtxCmd ¶
type CreateRawSSRtxCmd struct { Inputs []TransactionInput Fee *float64 }
CreateRawSSRtxCmd is a type handling custom marshaling and unmarshaling of createrawssrtx JSON RPC commands.
func NewCreateRawSSRtxCmd ¶
func NewCreateRawSSRtxCmd(inputs []TransactionInput, fee *float64) *CreateRawSSRtxCmd
NewCreateRawSSRtxCmd creates a new CreateRawSSRtxCmd.
type CreateRawSStxCmd ¶
type CreateRawSStxCmd struct { Inputs []SStxInput Amount map[string]int64 COuts []SStxCommitOut }
CreateRawSStxCmd is a type handling custom marshaling and unmarshaling of createrawsstx JSON RPC commands.
func NewCreateRawSStxCmd ¶
func NewCreateRawSStxCmd(inputs []SStxInput, amount map[string]int64, couts []SStxCommitOut) *CreateRawSStxCmd
NewCreateRawSStxCmd creates a new CreateRawSStxCmd.
type CreateRawTransactionCmd ¶
type CreateRawTransactionCmd struct { Inputs []TransactionInput Amounts map[string]float64 `jsonrpcusage:"{\"address\":amount,...}"` // In HCASH 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"` }
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 Error ¶
type Error struct { Code ErrorCode // Describes the kind of error Message 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.
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.
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 EstimateStakeDiffCmd ¶
type EstimateStakeDiffCmd struct {
Tickets *uint32
}
EstimateStakeDiffCmd defines the eststakedifficulty JSON-RPC command.
func NewEstimateStakeDiffCmd ¶
func NewEstimateStakeDiffCmd(tickets *uint32) *EstimateStakeDiffCmd
NewEstimateStakeDiffCmd defines the eststakedifficulty JSON-RPC command.
type EstimateStakeDiffResult ¶
type EstimateStakeDiffResult struct { Min float64 `json:"min"` Max float64 `json:"max"` Expected float64 `json:"expected"` User *float64 `json:"user,omitempty"` }
EstimateStakeDiffResult models the data returned from the estimatestakediff command.
type ExistsAddressCmd ¶
type ExistsAddressCmd struct {
Address string
}
ExistsAddressCmd defines the existsaddress JSON-RPC command.
func NewExistsAddressCmd ¶
func NewExistsAddressCmd(address string) *ExistsAddressCmd
NewExistsAddressCmd returns a new instance which can be used to issue a existsaddress JSON-RPC command.
type ExistsAddressesCmd ¶
type ExistsAddressesCmd struct {
Addresses []string
}
ExistsAddressesCmd defines the existsaddresses JSON-RPC command.
func NewExistsAddressesCmd ¶
func NewExistsAddressesCmd(addresses []string) *ExistsAddressesCmd
NewExistsAddressesCmd returns a new instance which can be used to issue an existsaddresses JSON-RPC command.
type ExistsExpiredTicketsCmd ¶
type ExistsExpiredTicketsCmd struct {
TxHashBlob string
}
ExistsExpiredTicketsCmd defines the existsexpiredtickets JSON-RPC command.
func NewExistsExpiredTicketsCmd ¶
func NewExistsExpiredTicketsCmd(txHashBlob string) *ExistsExpiredTicketsCmd
NewExistsExpiredTicketsCmd returns a new instance which can be used to issue an existsexpiredtickets JSON-RPC command.
type ExistsLiveTicketCmd ¶
type ExistsLiveTicketCmd struct {
TxHash string
}
ExistsLiveTicketCmd defines the existsliveticket JSON-RPC command.
func NewExistsLiveTicketCmd ¶
func NewExistsLiveTicketCmd(txHash string) *ExistsLiveTicketCmd
NewExistsLiveTicketCmd returns a new instance which can be used to issue an existsliveticket JSON-RPC command.
type ExistsLiveTicketsCmd ¶
type ExistsLiveTicketsCmd struct {
TxHashBlob string
}
ExistsLiveTicketsCmd defines the existslivetickets JSON-RPC command.
func NewExistsLiveTicketsCmd ¶
func NewExistsLiveTicketsCmd(txHashBlob string) *ExistsLiveTicketsCmd
NewExistsLiveTicketsCmd returns a new instance which can be used to issue an existslivetickets JSON-RPC command.
type ExistsMempoolTxsCmd ¶
type ExistsMempoolTxsCmd struct {
TxHashBlob string
}
ExistsMempoolTxsCmd defines the existsmempooltxs JSON-RPC command.
func NewExistsMempoolTxsCmd ¶
func NewExistsMempoolTxsCmd(txHashBlob string) *ExistsMempoolTxsCmd
NewExistsMempoolTxsCmd returns a new instance which can be used to issue an existslivetickets JSON-RPC command.
type ExistsMissedTicketsCmd ¶
type ExistsMissedTicketsCmd struct {
TxHashBlob string
}
ExistsMissedTicketsCmd defines the existsmissedtickets JSON-RPC command.
func NewExistsMissedTicketsCmd ¶
func NewExistsMissedTicketsCmd(txHashBlob string) *ExistsMissedTicketsCmd
NewExistsMissedTicketsCmd returns a new instance which can be used to issue an existsmissedtickets JSON-RPC command.
type ExportWatchingWalletCmd ¶
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 FeeInfoBlock ¶
type FeeInfoBlock struct { Height uint32 `json:"height"` Number uint32 `json:"number"` Min float64 `json:"min"` Max float64 `json:"max"` Mean float64 `json:"mean"` Median float64 `json:"median"` StdDev float64 `json:"stddev"` }
FeeInfoBlock is ticket fee information about a block.
type FeeInfoMempool ¶
type FeeInfoMempool struct { Number uint32 `json:"number"` Min float64 `json:"min"` Max float64 `json:"max"` Mean float64 `json:"mean"` Median float64 `json:"median"` StdDev float64 `json:"stddev"` }
FeeInfoMempool is ticket fee information about the mempool.
type FeeInfoRange ¶
type FeeInfoRange struct { Number uint32 `json:"number"` Min float64 `json:"min"` Max float64 `json:"max"` Mean float64 `json:"mean"` Median float64 `json:"median"` StdDev float64 `json:"stddev"` }
FeeInfoRange is ticket fee information about a range.
type FeeInfoWindow ¶
type FeeInfoWindow struct { StartHeight uint32 `json:"startheight"` EndHeight uint32 `json:"endheight"` Number uint32 `json:"number"` Min float64 `json:"min"` Max float64 `json:"max"` Mean float64 `json:"mean"` Median float64 `json:"median"` StdDev float64 `json:"stddev"` }
FeeInfoWindow is ticket fee information about an adjustment window.
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 GenerateVoteCmd ¶
type GenerateVoteCmd struct { BlockHash string Height int64 KeyHeight int64 TicketHash string VoteBits uint16 VoteBitsExt string }
GenerateVoteCmd is a type handling custom marshaling and unmarshaling of generatevote JSON wallet extension commands.
func NewGenerateVoteCmd ¶
func NewGenerateVoteCmd(blockhash string, height int64, keyHeight int64, tickethash string, votebits uint16, voteBitsExt string) *GenerateVoteCmd
NewGenerateVoteCmd creates a new GenerateVoteCmd.
type GenerateVoteResult ¶
type GenerateVoteResult struct {
Hex string `json:"hex"`
}
GenerateVoteResult models the data from the generatevote 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 GetAccountBalanceResult ¶
type GetAccountBalanceResult struct { AccountName string `json:"accountname"` ImmatureCoinbaseRewards float64 `json:"immaturecoinbaserewards"` ImmatureStakeGeneration float64 `json:"immaturestakegeneration"` LockedByTickets float64 `json:"lockedbytickets"` Spendable float64 `json:"spendable"` Total float64 `json:"total"` Unconfirmed float64 `json:"unconfirmed"` VotingAuthority float64 `json:"votingauthority"` }
GetAccountBalanceResult models the account data from the getbalance 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 ¶
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 ¶
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 GetBalanceResult ¶
type GetBalanceResult struct { Balances []GetAccountBalanceResult `json:"balances"` BlockHash string `json:"blockhash"` }
GetBalanceResult models the data from the getbalance 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 int64 `json:"height"` KeyHeight int64 `json:"keyheight"` }
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"` VerificationProgress float64 `json:"verificationprogress"` ChainWork string `json:"chainwork"` }
GetBlockChainInfoResult models the data returned from the getblockchaininfo command.
type GetBlockCmd ¶
type GetBlockCmd struct { Hash string Verbose *bool `jsonrpcdefault:"true"` VerboseTx *bool `jsonrpcdefault:"false"` }
GetBlockCmd defines the getblock JSON-RPC command.
func NewGetBlockCmd ¶
func NewGetBlockCmd(hash string, verbose, verboseTx *bool) *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 ¶
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"` Version int32 `json:"version"` PreviousHash string `json:"previousblockhash,omitempty"` MerkleRoot string `json:"merkleroot"` StakeRoot string `json:"stakeroot"` VoteBits uint16 `json:"votebits"` FinalState string `json:"finalstate"` Voters uint16 `json:"voters"` FreshStake uint8 `json:"freshstake"` Revocations uint8 `json:"revocations"` PoolSize uint32 `json:"poolsize"` Bits string `json:"bits"` SBits float64 `json:"sbits"` Height uint32 `json:"height"` Size uint32 `json:"size"` Time int64 `json:"time"` Nonce uint32 `json:"nonce"` StakeVersion uint32 `json:"stakeversion"` Difficulty float64 `json:"difficulty"` 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 GetBlockKeyHeightCmd ¶
type GetBlockKeyHeightCmd struct {
Height int64
}
GetBlockKeyHeightCmd defines the getblockkeyheight JSON-RPC command
func NewGetBlockKeyHeightCmd ¶
func NewGetBlockKeyHeightCmd(height int64) *GetBlockKeyHeightCmd
NewGetBlockKeyHeightCmd returns a new instance which can be used to issue a getblockkeyheight JSON-RPC command
type GetBlockSubsidyCmd ¶
GetBlockSubsidyCmd defines the getblocksubsidy JSON-RPC command.
func NewGetBlockSubsidyCmd ¶
func NewGetBlockSubsidyCmd(height int64, voters uint16) *GetBlockSubsidyCmd
NewGetBlockSubsidyCmd returns a new instance which can be used to issue a getblocksubsidy JSON-RPC command.
type GetBlockSubsidyResult ¶
type GetBlockSubsidyResult struct { Developer int64 `json:"developer"` PoS int64 `json:"pos"` PoW int64 `json:"pow"` Total int64 `json:"total"` }
GetBlockSubsidyResult models the data returned from the getblocksubsidy command.
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. // GBT has been modified from the Bitcoin semantics to include // the header rather than various components which are all part // of the header anyway. Header string `json:"header"` SigOpLimit int64 `json:"sigoplimit,omitempty"` SizeLimit int64 `json:"sizelimit,omitempty"` Transactions []GetBlockTemplateResultTx `json:"transactions"` STransactions []GetBlockTemplateResultTx `json:"stransactions"` 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"` SigOps int64 `json:"sigops"` TxType string `json:"txtype"` }
GetBlockTemplateResultTx models the transactions field of the getblocktemplate command.
type GetBlockVerboseResult ¶
type GetBlockVerboseResult struct { Hash string `json:"hash"` Confirmations int64 `json:"confirmations"` Size int32 `json:"size"` Height int64 `json:"height"` KeyHeight int64 `json:"keyheight"` IsKeyBlock bool `json:"iskeyblock"` Version int32 `json:"version"` MerkleRoot string `json:"merkleroot"` StakeRoot string `json:"stakeroot,omitempty"` Tx []string `json:"tx,omitempty"` RawTx []TxRawResult `json:"rawtx,omitempty"` STx []string `json:"stx,omitempty,omitempty"` RawSTx []TxRawResult `json:"rawstx,omitempty,omitempty"` Time int64 `json:"time"` Nonce uint32 `json:"nonce"` VoteBits uint16 `json:"votebits"` FinalState string `json:"finalstate"` Voters uint16 `json:"voters,omitempty"` FreshStake uint8 `json:"freshstake,omitempty"` Revocations uint8 `json:"revocations,omitempty"` PoolSize uint32 `json:"poolsize"` Bits string `json:"bits"` SBits float64 `json:"sbits,omitempty"` Difficulty float64 `json:"difficulty"` ExtraData string `json:"extradata"` StakeVersion uint32 `json:"stakeversion"` PreviousHash string `json:"previousblockhash"` PreviousKeyHash string `json:"previouskeyblockhash"` NextHash string `json:"nextblockhash,omitempty"` Reward float64 `json:"reward,omitempty"` }
GetBlockVerboseResult models the data from the getblock command when the verbose flag is set. When the verbose flag is not set, getblock returns a hex-encoded string. Contains Hypercash additions.
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 GetCoinSupplyCmd ¶
type GetCoinSupplyCmd struct{}
GetCoinSupplyCmd defines the getcoinsupply JSON-RPC command.
func NewGetCoinSupplyCmd ¶
func NewGetCoinSupplyCmd() *GetCoinSupplyCmd
NewGetCoinSupplyCmd returns a new instance which can be used to issue a getcoinsupply 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.
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.
type GetHeadersResult ¶
type GetHeadersResult struct {
Headers []string `json:"headers"`
}
GetHeadersResult models the data returned by the chain server getheaders command.
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 GetKeyBlockHashCmd ¶
type GetKeyBlockHashCmd struct {
KeyHeight int64
}
GetKeyBlockHash defines the getkeyblockhash JSON-RPC command
func NewGetKeyBlockHashCmd ¶
func NewGetKeyBlockHashCmd(keyHeight int64) *GetKeyBlockHashCmd
type GetMasterPubkeyCmd ¶
type GetMasterPubkeyCmd struct {
Account *string
}
GetMasterPubkeyCmd is a type handling custom marshaling and unmarshaling of getmasterpubkey JSON wallet extension commands.
func NewGetMasterPubkeyCmd ¶
func NewGetMasterPubkeyCmd(acct *string) *GetMasterPubkeyCmd
NewGetMasterPubkeyCmd creates a new GetMasterPubkeyCmd.
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 ¶
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"` StakeDifficulty int64 `json:"stakedifficulty"` Errors string `json:"errors"` Generate bool `json:"generate"` GenProcLimit int32 `json:"genproclimit"` HashesPerSec int64 `json:"hashespersec"` NetworkHashPS int64 `json:"networkhashps"` PooledTx uint64 `json:"pooledtx"` TestNet bool `json:"testnet"` }
GetMiningInfoResult models the data from the getmininginfo command. Contains Hypercash additions.
type GetMultisigOutInfoCmd ¶
GetMultisigOutInfoCmd is a type handling custom marshaling and unmarshaling of getmultisigoutinfo JSON websocket extension commands.
func NewGetMultisigOutInfoCmd ¶
func NewGetMultisigOutInfoCmd(hash string, index uint32) *GetMultisigOutInfoCmd
NewGetMultisigOutInfoCmd creates a new GetMultisigOutInfoCmd.
type GetMultisigOutInfoResult ¶
type GetMultisigOutInfoResult struct { Address string `json:"address"` RedeemScript string `json:"redeemscript"` M uint8 `json:"m"` N uint8 `json:"n"` Pubkeys []string `json:"pubkeys"` TxHash string `json:"txhash"` BlockHeight uint32 `json:"blockheight"` BlockHash string `json:"blockhash"` Spent bool `json:"spent"` SpentBy string `json:"spentby"` SpentByIndex uint32 `json:"spentbyindex"` Amount float64 `json:"amount"` }
GetMultisigOutInfoResult models the data returned from the getmultisigoutinfo 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"` ProtocolVersion int32 `json:"protocolversion"` TimeOffset int64 `json:"timeoffset"` Connections int32 `json:"connections"` Networks []NetworksResult `json:"networks"` RelayFee float64 `json:"relayfee"` LocalAddresses []LocalAddressesResult `json:"localaddresses"` }
GetNetworkInfoResult models the data returned from the getnetworkinfo command.
type GetNewAddressCmd ¶
GetNewAddressCmd defines the getnewaddress JSON-RPC command.
func NewGetNewAddressCmd ¶
func NewGetNewAddressCmd(account *string, gapPolicy *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"` 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 int64 `json:"startingheight"` CurrentHeight int64 `json:"currentheight,omitempty"` CurrentRealKeyHeight int64 `json:"currentrealkeyheight,omitempty"` BanScore int32 `json:"banscore"` 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 ¶
GetRawMempoolCmd defines the getmempool JSON-RPC command.
func NewGetRawMempoolCmd ¶
func NewGetRawMempoolCmd(verbose *bool, txType *string) *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 GetRawMempoolTxTypeCmd ¶
type GetRawMempoolTxTypeCmd string
GetRawMempoolTxTypeCmd defines the type used in the getrawmempool JSON-RPC command for the TxType command field.
const ( // GRMAll indicates any type of transaction should be returned. GRMAll GetRawMempoolTxTypeCmd = "all" // GRMRegular indicates only regular transactions should be returned. GRMRegular GetRawMempoolTxTypeCmd = "regular" // GRMTickets indicates that only tickets should be returned. GRMTickets GetRawMempoolTxTypeCmd = "tickets" // GRMVotes indicates that only votes should be returned. GRMVotes GetRawMempoolTxTypeCmd = "votes" // GRMRevocations indicates that only revocations should be returned. GRMRevocations GetRawMempoolTxTypeCmd = "revocations" )
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 ¶
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 *int) *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 ¶
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 ¶
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 GetSeedCmd ¶
type GetSeedCmd struct { }
GetSeedCmd is a type handling custom marshaling and unmarshaling of getseed JSON wallet extension commands.
type GetStakeDifficultyCmd ¶
type GetStakeDifficultyCmd struct{}
GetStakeDifficultyCmd is a type handling custom marshaling and unmarshaling of getstakedifficulty JSON RPC commands.
func NewGetStakeDifficultyCmd ¶
func NewGetStakeDifficultyCmd() *GetStakeDifficultyCmd
NewGetStakeDifficultyCmd returns a new instance which can be used to issue a JSON-RPC getstakedifficulty command.
type GetStakeDifficultyResult ¶
type GetStakeDifficultyResult struct { CurrentStakeDifficulty float64 `json:"current"` NextStakeDifficulty float64 `json:"next"` }
GetStakeDifficultyResult models the data returned from the getstakedifficulty command.
type GetStakeInfoCmd ¶
type GetStakeInfoCmd struct {
IsLiveTicketDetails *bool `jsonrpcdefault:"false"`
}
GetStakeInfoCmd is a type handling custom marshaling and unmarshaling of getstakeinfo JSON wallet extension commands.
func NewGetStakeInfoCmd ¶
func NewGetStakeInfoCmd() *GetStakeInfoCmd
NewGetStakeInfoCmd creates a new GetStakeInfoCmd.
type GetStakeInfoResult ¶
type GetStakeInfoResult struct { BlockHeight int64 `json:"blockheight"` PoolSize uint32 `json:"poolsize"` Difficulty float64 `json:"difficulty"` AllMempoolTix uint32 `json:"allmempooltix"` OwnMempoolTix uint32 `json:"ownmempooltix"` Immature uint32 `json:"immature"` Live uint32 `json:"live"` ProportionLive float64 `json:"proportionlive"` Voted uint32 `json:"voted"` TotalSubsidy float64 `json:"totalsubsidy"` Missed uint32 `json:"missed"` ProportionMissed float64 `json:"proportionmissed"` Revoked uint32 `json:"revoked"` Expired uint32 `json:"expired"` LiveTicketDetails []LiveTicket `json:"liveticketdetails,omitempty"` }
GetStakeInfoResult models the data returned from the getstakeinfo command.
type GetStakeVersionInfoCmd ¶
type GetStakeVersionInfoCmd struct {
Count *int32
}
GetStakeVersionInfoCmd returns stake version info for the current interval. Optionally, Count indicates how many additional intervals to return.
func NewGetStakeVersionInfoCmd ¶
func NewGetStakeVersionInfoCmd(count int32) *GetStakeVersionInfoCmd
NewGetStakeVersionInfoCmd returns a new instance which can be used to issue a JSON-RPC getstakeversioninfo command.
type GetStakeVersionInfoResult ¶
type GetStakeVersionInfoResult struct { CurrentHeight int64 `json:"currentheight"` Hash string `json:"hash"` Intervals []VersionInterval `json:"intervals"` }
GetStakeVersionInfoResult models the resulting data for getstakeversioninfo command.
type GetStakeVersionsCmd ¶
GetStakeVersionsCmd returns stake version for a range of blocks. Count indicates how many blocks are walked backwards.
func NewGetStakeVersionsCmd ¶
func NewGetStakeVersionsCmd(hash string, count int32) *GetStakeVersionsCmd
NewGetStakeVersionsCmd returns a new instance which can be used to issue a JSON-RPC getstakeversions command.
type GetStakeVersionsResult ¶
type GetStakeVersionsResult struct {
StakeVersions []StakeVersions `json:"stakeversions"`
}
GetStakeVersionsResult models the data returned from the getstakeversions command.
type GetTicketFeeCmd ¶
type GetTicketFeeCmd struct { }
GetTicketFeeCmd is a type handling custom marshaling and unmarshaling of getticketfee JSON wallet extension commands.
func NewGetTicketFeeCmd ¶
func NewGetTicketFeeCmd() *GetTicketFeeCmd
NewGetTicketFeeCmd creates a new GetTicketFeeCmd.
type GetTicketPoolValueCmd ¶
type GetTicketPoolValueCmd struct{}
GetTicketPoolValueCmd defines the getticketpoolvalue JSON-RPC command.
func NewGetTicketPoolValueCmd ¶
func NewGetTicketPoolValueCmd() *GetTicketPoolValueCmd
NewGetTicketPoolValueCmd returns a new instance which can be used to issue a getticketpoolvalue JSON-RPC command.
type GetTicketsCmd ¶
type GetTicketsCmd struct {
IncludeImmature bool
}
GetTicketsCmd is a type handling custom marshaling and unmarshaling of gettickets JSON wallet extension commands.
func NewGetTicketsCmd ¶
func NewGetTicketsCmd(includeImmature bool) *GetTicketsCmd
NewGetTicketsCmd returns a new instance which can be used to issue a gettickets JSON-RPC command.
type GetTicketsResult ¶
type GetTicketsResult struct {
Hashes []string `json:"hashes"`
}
GetTicketsResult models the data returned from the gettickets command.
type GetTransactionCmd ¶
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 ¶
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 GetTxOutResult ¶
type GetTxOutResult struct { BestBlock string `json:"bestblock"` Confirmations int64 `json:"confirmations"` Value float64 `json:"value"` ScriptPubKey ScriptPubKeyResult `json:"scriptPubKey"` Version int32 `json:"version"` 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 GetVoteChoicesCmd ¶
type GetVoteChoicesCmd struct { }
GetVoteChoicesCmd returns a new instance which can be used to issue a getvotechoices JSON-RPC command.
func NewGetVoteChoicesCmd ¶
func NewGetVoteChoicesCmd() *GetVoteChoicesCmd
NewGetVoteChoicesCmd returns a new instance which can be used to issue a JSON-RPC getvotechoices command.
type GetVoteChoicesResult ¶
type GetVoteChoicesResult struct { Version uint32 `json:"version"` Choices []VoteChoice `json:"choices"` }
GetVoteChoicesResult models the data returned by the getvotechoices command.
type GetVoteInfoCmd ¶
type GetVoteInfoCmd struct {
Version uint32
}
GetVoteInfoCmd returns voting results over a range of blocks. Count indicates how many blocks are walked backwards.
func NewGetVoteInfoCmd ¶
func NewGetVoteInfoCmd(version uint32) *GetVoteInfoCmd
NewGetVoteInfoCmd returns a new instance which can be used to issue a JSON-RPC getvoteinfo command.
type GetVoteInfoResult ¶
type GetVoteInfoResult struct { CurrentHeight int64 `json:"currentheight"` StartHeight int64 `json:"startheight"` EndHeight int64 `json:"endheight"` Hash string `json:"hash"` VoteVersion uint32 `json:"voteversion"` Quorum uint32 `json:"quorum"` TotalVotes uint32 `json:"totalvotes"` Agendas []Agenda `json:"agendas,omitempty"` }
GetVoteInfoResult models the data returned from the getvoteinfo command.
type GetWalletFeeCmd ¶
type GetWalletFeeCmd struct{}
GetWalletFeeCmd defines the getwalletfee JSON-RPC command.
func NewGetWalletFeeCmd ¶
func NewGetWalletFeeCmd() *GetWalletFeeCmd
NewGetWalletFeeCmd returns a new instance which can be used to issue a getwalletfee 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 ¶
GetWorkResult models the data from the getwork command.
type HelpCmd ¶
type HelpCmd struct {
Command *string
}
HelpCmd defines the help JSON-RPC command.
func NewHelpCmd ¶
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 ¶
ImportAddressCmd defines the importaddress JSON-RPC command.
func NewImportAddressCmd ¶
func NewImportAddressCmd(address 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"` ScanFrom *int }
ImportPrivKeyCmd defines the importprivkey JSON-RPC command.
func NewImportPrivKeyCmd ¶
func NewImportPrivKeyCmd(privKey string, label *string, rescan *bool, scanFrom *int) *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 ¶
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 ImportScriptCmd ¶
ImportScriptCmd is a type for handling custom marshaling and unmarshaling of importscript JSON wallet extension commands.
func NewImportScriptCmd ¶
func NewImportScriptCmd(hex string, rescan *bool, scanFrom *int) *ImportScriptCmd
NewImportScriptCmd creates a new GetImportScriptCmd.
type InfoChainResult ¶
type InfoChainResult struct { Version int32 `json:"version"` ProtocolVersion int32 `json:"protocolversion"` Blocks int64 `json:"blocks"` KeyBlocks int64 `json:"keyblocks"` 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"` HashCount float64 `json:"hashcount"` }
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 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 ListAddressTransactionsCmd ¶
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 ListScriptsCmd ¶
type ListScriptsCmd struct { }
ListScriptsCmd is a type for handling custom marshaling and unmarshaling of listscripts JSON wallet extension commands.
func NewListScriptsCmd ¶
func NewListScriptsCmd() *ListScriptsCmd
NewListScriptsCmd returns a new instance which can be used to issue a listscripts JSON-RPC command.
type ListScriptsResult ¶
type ListScriptsResult struct {
Scripts []ScriptInfo `json:"scripts"`
}
ListScriptsResult models the data returned from the listscripts 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 { Account string `json:"account"` Address string `json:"address,omitempty"` Amount float64 `json:"amount"` 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"` TxID string `json:"txid"` TxType *ListTransactionsTxType `json:"txtype,omitempty"` 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 ListTransactionsTxType ¶
type ListTransactionsTxType string
ListTransactionsTxType defines the type used in the listtransactions JSON-RPC result for the TxType command field.
const ( // LTTTRegular indicates a regular transaction. LTTTRegular ListTransactionsTxType = "regular" // LTTTRegular indicates a regular send transaction. LTTTSend ListTransactionsTxType = "send" // LTTTRegular indicates a regular receive transaction. LTTTReceive ListTransactionsTxType = "receive" // LTTTRegular indicates a coinbase transaction. LTTTCoinbase ListTransactionsTxType = "coinbase" // LTTTTicket indicates a ticket. LTTTTicket ListTransactionsTxType = "ticket" // LTTTVote indicates a vote. LTTTVote ListTransactionsTxType = "vote" // LTTTRevocation indicates a revocation. LTTTRevocation ListTransactionsTxType = "revocation" )
type ListTxsCmd ¶
type ListTxsCmd struct { Account *string TxType *int `jsonrpcdefault:"63"` Count *int64 `jsonrpcdefault:"10"` From *int64 `jsonrpcdefault:"0"` IncludeWatchOnly *bool `jsonrpcdefault:"false"` }
ListTxsCmd defines the listtxs JSON-RPC command.
func NewListTxsCmd ¶
func NewListTxsCmd(account *string, txType *int, count, from *int64, includeWatchOnly *bool) *ListTxsCmd
NewListTxsCmd returns a new instance which can be used to issue a listtxs JSON-RPC command.
The parameters which are pointers indicate they are optional. Passing nil for optional parameters will use the default value.
type ListTxsElem ¶
type ListTxsElem struct { Account string `json:"account"` Amount float64 `json:"amount"` Fee float64 `json:"fee,omitempty"` Confirmations int64 `json:"confirmations"` BlockHash string `json:"blockhash"` BlockHeight int64 `json:"blockheight"` BlockKeyHeight int64 `json:"keyblockheight"` BlockIndex *int64 `json:"blockindex,omitempty"` BlockTime int64 `json:"blocktime,omitempty"` TxID string `json:"txid"` WalletConflicts []string `json:"walletconflicts"` TimeReceived int64 `json:"timereceived"` InvolvesWatchOnly bool `json:"involveswatchonly,omitempty"` Comment string `json:"comment,omitempty"` OtherAccount string `json:"otheraccount,omitempty"` TxType *ListTransactionsTxType `json:"txtype,omitempty"` StakeDiff float64 `json:"stakediff,omitempty"` Source []string `json:"source,omitempty"` Dest []string `json:"dest,omitempty"` }
type ListTxsResult ¶
type ListTxsResult struct { TotalNum int64 `json:"totalnum"` Transactions *[]ListTxsElem `json:"tranactions"` }
ListTxsResult models the data from the listtxs 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"` Tree int8 `json:"tree"` TxType int `json:"txtype"` 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. Contains Hypercash additions.
type LiveTicket ¶
type LiveTicket struct { TxHash string `json:"txhash"` Stakediff float64 `json:"stakediff"` BlockHash string `json:"blockhash"` BlockHeight int64 `json:"blockheight"` BlockKeyHeight int64 `json:"blockkeyheight"` ReceivedTime int64 `json:"receivedTime"` }
LiveTicket models the data for a live ticket in the GetStakeInfoResult command.
type LiveTicketsCmd ¶
type LiveTicketsCmd struct{}
LiveTicketsCmd is a type handling custom marshaling and unmarshaling of livetickets JSON RPC commands.
func NewLiveTicketsCmd ¶
func NewLiveTicketsCmd() *LiveTicketsCmd
NewLiveTicketsCmd returns a new instance which can be used to issue a JSON-RPC livetickets command.
type LiveTicketsResult ¶
type LiveTicketsResult struct {
Tickets []string `json:"tickets"`
}
LiveTicketsResult models the data returned from the livetickets command.
type LoadTxFilterCmd ¶
LoadTxFilterCmd defines the loadtxfilter request parameters to load or reload a transaction filter.
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.
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 MissedTicketsCmd ¶
type MissedTicketsCmd struct{}
MissedTicketsCmd is a type handling custom marshaling and unmarshaling of missedtickets JSON RPC commands.
func NewMissedTicketsCmd ¶
func NewMissedTicketsCmd() *MissedTicketsCmd
NewMissedTicketsCmd returns a new instance which can be used to issue a JSON-RPC missedtickets command.
type MissedTicketsResult ¶
type MissedTicketsResult struct {
Tickets []string `json:"tickets"`
}
MissedTicketsResult models the data returned from the missedtickets command.
type NetworksResult ¶
type NetworksResult struct { Name string `json:"name"` Limited bool `json:"limited"` Reachable bool `json:"reachable"` Proxy string `json:"proxy"` }
NetworksResult models the networks data from the getnetworkinfo command.
type NewTicketsNtfn ¶
NewTicketsNtfn is a type handling custom marshaling and unmarshaling of newtickets JSON websocket notifications.
func NewNewTicketsNtfn ¶
func NewNewTicketsNtfn(hash string, height int32, stakeDiff int64, tickets []string) *NewTicketsNtfn
NewNewTicketsNtfn creates a new NewTicketsNtfn.
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 NotifyNewTicketsCmd ¶
type NotifyNewTicketsCmd struct { }
NotifyNewTicketsCmd is a type handling custom marshaling and unmarshaling of notifynewtickets JSON websocket extension commands.
func NewNotifyNewTicketsCmd ¶
func NewNotifyNewTicketsCmd() *NotifyNewTicketsCmd
NewNotifyNewTicketsCmd creates a new NotifyNewTicketsCmd.
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 NotifySpentAndMissedTicketsCmd ¶
type NotifySpentAndMissedTicketsCmd struct { }
NotifySpentAndMissedTicketsCmd is a type handling custom marshaling and unmarshaling of notifyspentandmissedtickets JSON websocket extension commands.
func NewNotifySpentAndMissedTicketsCmd ¶
func NewNotifySpentAndMissedTicketsCmd() *NotifySpentAndMissedTicketsCmd
NewNotifySpentAndMissedTicketsCmd creates a new NotifySpentAndMissedTicketsCmd.
type NotifyStakeDifficultyCmd ¶
type NotifyStakeDifficultyCmd struct { }
NotifyStakeDifficultyCmd is a type handling custom marshaling and unmarshaling of notifystakedifficulty JSON websocket extension commands.
func NewNotifyStakeDifficultyCmd ¶
func NewNotifyStakeDifficultyCmd() *NotifyStakeDifficultyCmd
NewNotifyStakeDifficultyCmd creates a new NotifyStakeDifficultyCmd.
type NotifyWinningTicketsCmd ¶
type NotifyWinningTicketsCmd struct { }
NotifyWinningTicketsCmd is a type handling custom marshaling and unmarshaling of notifywinningtickets JSON websocket extension commands.
func NewNotifyWinningTicketsCmd ¶
func NewNotifyWinningTicketsCmd() *NotifyWinningTicketsCmd
NewNotifyWinningTicketsCmd creates a new NotifyWinningTicketsCmd.
type OutPoint ¶
type OutPoint struct { Hash string `json:"hash"` Tree int8 `json:"tree"` Index uint32 `json:"index"` }
OutPoint describes a transaction outpoint that will be marshalled to and from JSON. Contains Hypercash addition.
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 PoolUserTicket ¶
type PoolUserTicket struct { Status string `json:"status"` Ticket string `json:"ticket"` TicketHeight uint32 `json:"ticketheight"` SpentBy string `json:"spentby"` SpentByHeight uint32 `json:"spentbyheight"` }
PoolUserTicket is the JSON struct corresponding to a stake pool user ticket object.
type PrevOut ¶
type PrevOut struct { Addresses []string `json:"addresses,omitempty"` Value float64 `json:"value"` }
PrevOut represents previous output for an input Vin.
type PurchaseTicketCmd ¶
type PurchaseTicketCmd struct { FromAccount string SpendLimit float64 // In Coins MinConf *int `jsonrpcdefault:"1"` TicketAddress *string NumTickets *int PoolAddress *string PoolFees *float64 Expiry *int Comment *string }
PurchaseTicketCmd is a type handling custom marshaling and unmarshaling of purchaseticket JSON RPC commands.
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.
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 )
General application defined JSON errors.
const ( ErrRPCClientNotConnected RPCErrorCode = -9 ErrRPCClientInInitialDownload RPCErrorCode = -10 )
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 ErrRPCNoNewestBlockInfo RPCErrorCode = -5 ErrRPCInvalidTxVout RPCErrorCode = -5 ErrRPCRawTxString RPCErrorCode = -32602 ErrRPCDecodeHexString RPCErrorCode = -22 )
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"` Tree int8 `json:"tree"` ScriptPubKey string `json:"scriptPubKey"` RedeemScript string `json:"redeemScript"` }
RawTxInput models the data needed for raw transaction input that is used in the SignRawTransactionCmd struct. Contains Hypercash additions.
type RebroadcastMissedCmd ¶
type RebroadcastMissedCmd struct{}
RebroadcastMissedCmd is a type handling custom marshaling and unmarshaling of rebroadcastwinners JSON RPC commands.
func NewRebroadcastMissedCmd ¶
func NewRebroadcastMissedCmd() *RebroadcastMissedCmd
NewRebroadcastMissedCmd returns a new instance which can be used to issue a JSON-RPC rebroadcastmissed command.
type RebroadcastWinnersCmd ¶
type RebroadcastWinnersCmd struct{}
RebroadcastWinnersCmd is a type handling custom marshaling and unmarshaling of rebroadcastwinners JSON RPC commands.
func NewRebroadcastWinnersCmd ¶
func NewRebroadcastWinnersCmd() *RebroadcastWinnersCmd
NewRebroadcastWinnersCmd returns a new instance which can be used to issue a JSON-RPC rebroadcastwinners command.
type RecoverAddressesCmd ¶
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 RedeemMultiSigOutCmd ¶
RedeemMultiSigOutCmd is a type handling custom marshaling and unmarshaling of redeemmultisigout JSON RPC commands.
func NewRedeemMultiSigOutCmd ¶
func NewRedeemMultiSigOutCmd(hash string, index uint32, tree int8, address *string) *RedeemMultiSigOutCmd
NewRedeemMultiSigOutCmd creates a new RedeemMultiSigOutCmd.
type RedeemMultiSigOutResult ¶
type RedeemMultiSigOutResult struct { Hex string `json:"hex"` Complete bool `json:"complete"` Errors []SignRawTransactionError `json:"errors,omitempty"` }
RedeemMultiSigOutResult models the data returned from the redeemmultisigout command.
type RedeemMultiSigOutsCmd ¶
RedeemMultiSigOutsCmd is a type handling custom marshaling and unmarshaling of redeemmultisigout JSON RPC commands.
func NewRedeemMultiSigOutsCmd ¶
func NewRedeemMultiSigOutsCmd(from string, to *string, number *int) *RedeemMultiSigOutsCmd
NewRedeemMultiSigOutsCmd creates a new RedeemMultiSigOutsCmd.
type RedeemMultiSigOutsResult ¶
type RedeemMultiSigOutsResult struct {
Results []RedeemMultiSigOutResult `json:"results"`
}
RedeemMultiSigOutsResult models the data returned from the redeemmultisigouts command.
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 ¶
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 ReorganizationNtfn ¶
type ReorganizationNtfn struct { OldHash string `json:"oldhash"` OldHeight int32 `json:"oldheight"` NewHash string `json:"newhash"` NewHeight int32 `json:"newheight"` }
ReorganizationNtfn defines the reorganization JSON-RPC notification.
func NewReorganizationNtfn ¶
func NewReorganizationNtfn(oldHash string, oldHeight int32, newHash string, newHeight int32) *ReorganizationNtfn
NewReorganizationNtfn returns a new instance which can be used to issue a blockdisconnected JSON-RPC notification.
type Request ¶
type Request struct { Jsonrpc string `json:"jsonrpc"` Method string `json:"method"` Params []json.RawMessage `json:"params"` ID interface{} `json:"id"` }
Request is a type for raw JSON-RPC 1.0 requests. The Method field identifies the specific command type which in turns 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 it being exported in case the caller wants to construct raw requests for some reason.
func NewRequest ¶
NewRequest returns a new JSON-RPC 1.0 request object given the provided 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.
type RescanCmd ¶
type RescanCmd struct { // Concatenated block hashes in non-byte-reversed hex encoding. Must // have length evenly divisible by 2*chainhash.HashSize. BlockHashes string }
RescanCmd defines the rescan JSON-RPC command.
func NewRescanCmd ¶
NewRescanCmd returns a new instance which can be used to issue a rescan JSON-RPC command.
type RescanResult ¶
type RescanResult struct {
DiscoveredData []RescannedBlock `json:"discovereddata"`
}
RescanResult models the result object returned by the rescan RPC.
type RescanWalletCmd ¶
type RescanWalletCmd struct {
BeginHeight *int `jsonrpcdefault:"0"`
}
RescanWalletCmd describes the rescanwallet JSON-RPC request and parameters.
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.
type Response ¶
type Response struct { 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 for Go to put a null in it when empty.
func NewResponse ¶
NewResponse returns a new JSON-RPC response object given the provided 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 RevocationCreatedNtfn ¶
RevocationCreatedNtfn is a type handling custom marshaling and unmarshaling of ticketpurchased JSON websocket notifications.
func NewRevocationCreatedNtfn ¶
func NewRevocationCreatedNtfn(txHash string, sstxIn string) *RevocationCreatedNtfn
NewRevocationCreatedNtfn creates a new RevocationCreatedNtfn.
type RevokeTicketsCmd ¶
type RevokeTicketsCmd struct { }
RevokeTicketsCmd describes the revoketickets JSON-RPC request and parameters.
func NewRevokeTicketsCmd ¶
func NewRevokeTicketsCmd() *RevokeTicketsCmd
NewRevokeTicketsCmd creates a new RevokeTicketsCmd.
type SStxCommitOut ¶
type SStxCommitOut struct { Addr string `json:"addr"` CommitAmt int64 `json:"commitamt"` ChangeAddr string `json:"changeaddr"` ChangeAmt int64 `json:"changeamt"` }
SStxCommitOut represents the output to an SStx transaction. Specifically a a commitment address and amount, and a change address and amount.
type SStxInput ¶
type SStxInput struct { Txid string `json:"txid"` Vout uint32 `json:"vout"` Tree int8 `json:"tree"` Amt int64 `json:"amt"` }
SStxInput represents the inputs to an SStx transaction. Specifically a transactionsha and output number pair, along with the output amounts.
type ScriptInfo ¶
type ScriptInfo struct { Hash160 string `json:"hash160"` Address string `json:"address"` RedeemScript string `json:"redeemscript"` }
ScriptInfo is the structure representing a redeem script, its hash, and its address.
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"` CommitAmt *float64 `json:"commitamt,omitempty"` }
ScriptPubKeyResult models the scriptPubKey data of a tx script. It is defined separately since it is used by multiple commands.
type ScriptSig ¶
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 *int `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, 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"` 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 HCASH NotSend *int `jsonrpcdefault:"0"` MinConf *int `jsonrpcdefault:"1"` Comment *string CommentTo *string }
SendFromCmd defines the sendfrom JSON-RPC command.
func NewSendFromCmd ¶
func NewSendFromCmd(fromAccount, toAddress string, amount float64, notSend, 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 HCASH NotSend *int `jsonrpcdefault:"0"` 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 ¶
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 NotSend *int `jsonrpcdefault:"0"` Comment *string CommentTo *string }
SendToAddressCmd defines the sendtoaddress JSON-RPC command.
func NewSendToAddressCmd ¶
func NewSendToAddressCmd(address string, amount float64, notSend int, comment, commentTo *string) *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 SendToMultiSigCmd ¶
type SendToMultiSigCmd struct { FromAccount string Amount float64 Pubkeys []string NRequired *int `jsonrpcdefault:"1"` MinConf *int `jsonrpcdefault:"1"` Comment *string }
SendToMultiSigCmd is a type handling custom marshaling and unmarshaling of sendtomultisig JSON RPC commands.
func NewSendToMultiSigCmd ¶
func NewSendToMultiSigCmd(fromaccount string, amount float64, pubkeys []string, nrequired *int, minConf *int, comment *string) *SendToMultiSigCmd
NewSendToMultiSigCmd creates a new SendToMultiSigCmd.
type SendToMultiSigResult ¶
type SendToMultiSigResult struct { TxHash string `json:"txhash"` Address string `json:"address"` RedeemScript string `json:"redeemscript"` }
SendToMultiSigResult models the data returned from the sendtomultisig command.
type SendToSSGenCmd ¶
type SendToSSGenCmd struct { FromAccount string TicketHash string BlockHash string Height int64 VoteBits uint16 Comment *string }
SendToSSGenCmd models the data needed for sendtossgen.
func NewSendToSSGenCmd ¶
func NewSendToSSGenCmd(fromaccount string, tickethash string, blockhash string, height int64, votebits uint16, comment *string) *SendToSSGenCmd
NewSendToSSGenCmd creates a new SendToSSGenCmd. Optionally a pointer to a TemplateRequest may be provided.
type SendToSSRtxCmd ¶
SendToSSRtxCmd is a type handling custom marshaling and unmarshaling of sendtossrtx JSON RPC commands.
func NewSendToSSRtxCmd ¶
func NewSendToSSRtxCmd(fromaccount string, tickethash string, comment *string) *SendToSSRtxCmd
NewSendToSSRtxCmd creates a new SendToSSRtxCmd. Optionally a pointer to a TemplateRequest may be provided.
type SendToSStxCmd ¶
type SendToSStxCmd struct { FromAccount string Amounts map[string]int64 Inputs []SStxInput COuts []SStxCommitOut MinConf *int `jsonrpcdefault:"1"` Comment *string }
SendToSStxCmd is a type handling custom marshaling and unmarshaling of sendtosstx JSON RPC commands.
func NewSendToSStxCmd ¶
func NewSendToSStxCmd(fromaccount string, amounts map[string]int64, inputs []SStxInput, couts []SStxCommitOut, minConf *int, comment *string) *SendToSStxCmd
NewSendToSStxCmd creates a new SendToSStxCmd. Optionally a pointer to a TemplateRequest may be provided.
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 SetBalanceToMaintainCmd ¶
type SetBalanceToMaintainCmd struct {
Balance float64
}
SetBalanceToMaintainCmd is a type handling custom marshaling and unmarshaling of setbalancetomaintain JSON RPC commands.
func NewSetBalanceToMaintainCmd ¶
func NewSetBalanceToMaintainCmd(balance float64) *SetBalanceToMaintainCmd
NewSetBalanceToMaintainCmd creates a new instance of the setticketfee command.
type SetGenerateCmd ¶
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 SetTicketFeeCmd ¶
type SetTicketFeeCmd struct {
Fee float64
}
SetTicketFeeCmd is a type handling custom marshaling and unmarshaling of setticketfee JSON RPC commands.
func NewSetTicketFeeCmd ¶
func NewSetTicketFeeCmd(fee float64) *SetTicketFeeCmd
NewSetTicketFeeCmd creates a new instance of the setticketfee command.
type SetTicketMaxPriceCmd ¶
type SetTicketMaxPriceCmd struct {
Max float64
}
SetTicketMaxPriceCmd is a type handling custom marshaling and unmarshaling of setticketmaxprice JSON RPC commands.
func NewSetTicketMaxPriceCmd ¶
func NewSetTicketMaxPriceCmd(max float64) *SetTicketMaxPriceCmd
NewSetTicketMaxPriceCmd creates a new instance of the setticketmaxprice command.
type SetTxFeeCmd ¶
type SetTxFeeCmd struct {
Amount float64 // In HCASH
}
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 SetVoteChoiceCmd ¶
SetVoteChoiceCmd defines the parameters to the setvotechoice method.
func NewSetVoteChoiceCmd ¶
func NewSetVoteChoiceCmd(agendaID, choiceID string) *SetVoteChoiceCmd
NewSetVoteChoiceCmd returns a new instance which can be used to issue a setvotechoice JSON-RPC command.
type SignMessageCmd ¶
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 SignRawTransactionsCmd ¶
SignRawTransactionsCmd defines the signrawtransactions JSON-RPC command.
func NewSignRawTransactionsCmd ¶
func NewSignRawTransactionsCmd(hexEncodedTxs []string, send *bool) *SignRawTransactionsCmd
NewSignRawTransactionsCmd returns a new instance which can be used to issue a signrawtransactions JSON-RPC command.
type SignRawTransactionsResult ¶
type SignRawTransactionsResult struct {
Results []SignedTransaction `json:"results"`
}
SignRawTransactionsResult models the data returned from the signrawtransactions command.
type SignedTransaction ¶
type SignedTransaction struct { SigningResult SignRawTransactionResult `json:"signingresult"` Sent bool `json:"sent"` TxHash *string `json:"txhash,omitempty"` }
SignedTransaction is a signed transaction resulting from a signrawtransactions command.
type SpentAndMissedTicketsNtfn ¶
type SpentAndMissedTicketsNtfn struct { Hash string Height int32 StakeDiff int64 Tickets map[string]string }
SpentAndMissedTicketsNtfn is a type handling custom marshaling and unmarshaling of spentandmissedtickets JSON websocket notifications.
func NewSpentAndMissedTicketsNtfn ¶
func NewSpentAndMissedTicketsNtfn(hash string, height int32, stakeDiff int64, tickets map[string]string) *SpentAndMissedTicketsNtfn
NewSpentAndMissedTicketsNtfn creates a new SpentAndMissedTicketsNtfn.
type StakeDifficultyNtfn ¶
StakeDifficultyNtfn is a type handling custom marshaling and unmarshaling of stakedifficulty JSON websocket notifications.
func NewStakeDifficultyNtfn ¶
func NewStakeDifficultyNtfn(hash string, height int32, stakeDiff int64) *StakeDifficultyNtfn
NewStakeDifficultyNtfn creates a new StakeDifficultyNtfn.
type StakePoolUserInfoCmd ¶
type StakePoolUserInfoCmd struct {
User string
}
StakePoolUserInfoCmd defines the stakepooluserinfo JSON-RPC command.
func NewStakePoolUserInfoCmd ¶
func NewStakePoolUserInfoCmd(user string) *StakePoolUserInfoCmd
NewStakePoolUserInfoCmd returns a new instance which can be used to issue a signrawtransactions JSON-RPC command.
type StakePoolUserInfoResult ¶
type StakePoolUserInfoResult struct { Tickets []PoolUserTicket `json:"tickets"` InvalidTickets []string `json:"invalid"` }
StakePoolUserInfoResult models the data returned from the stakepooluserinfo command.
type StakeVersions ¶
type StakeVersions struct { Hash string `json:"hash"` Height int64 `json:"height"` BlockVersion int32 `json:"blockversion"` StakeVersion uint32 `json:"stakeversion"` Votes []VersionBits `json:"votes"` }
StakeVersions models the data for GetStakeVersionsResult.
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 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 TicketFeeInfoCmd ¶
TicketFeeInfoCmd defines the ticketsfeeinfo JSON-RPC command.
func NewTicketFeeInfoCmd ¶
func NewTicketFeeInfoCmd(blocks *uint32, windows *uint32) *TicketFeeInfoCmd
NewTicketFeeInfoCmd returns a new instance which can be used to issue a JSON-RPC ticket fee info command.
type TicketFeeInfoResult ¶
type TicketFeeInfoResult struct { FeeInfoMempool FeeInfoMempool `json:"feeinfomempool"` FeeInfoBlocks []FeeInfoBlock `json:"feeinfoblocks"` FeeInfoWindows []FeeInfoWindow `json:"feeinfowindows"` }
TicketFeeInfoResult models the data returned from the ticketfeeinfo command. command.
type TicketPurchasedNtfn ¶
TicketPurchasedNtfn is a type handling custom marshaling and unmarshaling of ticketpurchased JSON websocket notifications.
func NewTicketPurchasedNtfn ¶
func NewTicketPurchasedNtfn(txHash string, amount int64) *TicketPurchasedNtfn
NewTicketPurchasedNtfn creates a new TicketPurchasedNtfn.
type TicketVWAPCmd ¶
TicketVWAPCmd defines the ticketvwap JSON-RPC command.
func NewTicketVWAPCmd ¶
func NewTicketVWAPCmd(start *uint32, end *uint32, height *uint32) *TicketVWAPCmd
NewTicketVWAPCmd returns a new instance which can be used to issue a JSON-RPC ticket volume weight average price command.
type TicketsForAddressCmd ¶
type TicketsForAddressCmd struct {
Address string
}
TicketsForAddressCmd defines the ticketsforbucket JSON-RPC command.
func NewTicketsForAddressCmd ¶
func NewTicketsForAddressCmd(addr string) *TicketsForAddressCmd
NewTicketsForAddressCmd returns a new instance which can be used to issue a JSON-RPC tickets for bucket command.
type TicketsForAddressResult ¶
type TicketsForAddressResult struct {
Tickets []string `json:"tickets"`
}
TicketsForAddressResult models the data returned from the ticketforaddress command.
type TransactionInput ¶
type TransactionInput struct { Txid string `json:"txid"` Vout uint32 `json:"vout"` Tree int8 `json:"tree"` }
TransactionInput represents the inputs to a transaction. Specifically a transaction hash and output number pair. Contains Hypercash additions.
type TxAcceptedNtfn ¶
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 `json:"rawtx"`
}
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 TxFeeInfoCmd ¶
TxFeeInfoCmd defines the ticketsfeeinfo JSON-RPC command.
func NewTxFeeInfoCmd ¶
func NewTxFeeInfoCmd(blocks *uint32, start *uint32, end *uint32) *TxFeeInfoCmd
NewTxFeeInfoCmd returns a new instance which can be used to issue a JSON-RPC ticket fee info command.
type TxFeeInfoResult ¶
type TxFeeInfoResult struct { FeeInfoMempool FeeInfoMempool `json:"feeinfomempool"` FeeInfoBlocks []FeeInfoBlock `json:"feeinfoblocks"` FeeInfoRange FeeInfoRange `json:"feeinforange"` }
TxFeeInfoResult models the data returned from the ticketfeeinfo command. command.
type TxRawDecodeResult ¶
type TxRawDecodeResult struct { Txid string `json:"txid"` Version int32 `json:"version"` Locktime uint32 `json:"locktime"` Expiry uint32 `json:"expiry"` 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"` Txid string `json:"txid"` Version int32 `json:"version"` LockTime uint32 `json:"locktime"` Expiry uint32 `json:"expiry"` Vin []Vin `json:"vin"` Vout []Vout `json:"vout"` BlockHash string `json:"blockhash,omitempty"` BlockHeight int64 `json:"blockheight"` BlockKeyHeight int64 `json:"blockkeyheight"` BlockIndex uint32 `json:"blockindex,omitempty"` Confirmations int64 `json:"confirmations,omitempty"` Time int64 `json:"time,omitempty"` Blocktime int64 `json:"blocktime,omitempty"` TxType string `json:"txtype"` Fee float64 `json:"fee,omitempty"` Size int `json:"size"` VotePassed bool `json:"votepassed,omitempty"` }
TxRawResult models the data from the getrawtransaction 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 ¶
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.
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"` PubKeyAddr string `json:"pubkeyaddr,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 VerifyChainCmd ¶
type VerifyChainCmd struct { CheckLevel *int64 `jsonrpcdefault:"3"` CheckDepth *int64 `jsonrpcdefault:"288"` // 0 = all }
VerifyChainCmd defines the verifychain JSON-RPC command.
func NewVerifyChainCmd ¶
func NewVerifyChainCmd(checkLevel, checkDepth *int64) *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 ¶
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 VersionBits ¶
VersionBits models a generic version:bits tuple.
type VersionCmd ¶
type VersionCmd struct{}
VersionCmd defines the version JSON-RPC command.
func NewVersionCmd ¶
func NewVersionCmd() *VersionCmd
NewVersionCmd returns a new instance which can be used to issue a JSON-RPC version command.
type VersionCount ¶
VersionCount models a generic version:count tuple.
type VersionInterval ¶
type VersionInterval struct { StartHeight int64 `json:"startheight"` EndHeight int64 `json:"endheight"` PoSVersions []VersionCount `json:"posversions"` VoteVersions []VersionCount `json:"voteversions"` }
VersionInterval models a cooked version count for an interval.
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.
type Vin ¶
type Vin struct { Coinbase string `json:"coinbase"` Txid string `json:"txid"` Vout uint32 `json:"vout"` Tree int8 `json:"tree"` Sequence uint32 `json:"sequence"` AmountIn float64 `json:"amountin"` BlockHeight uint32 `json:"blockheight"` BlockIndex uint32 `json:"blockindex"` ScriptSig *ScriptSig `json:"scriptSig"` }
Vin models parts of the tx data. It is defined separately since getrawtransaction, decoderawtransaction, and searchrawtransaction use the same structure.
func (*Vin) IsCoinBase ¶
IsCoinBase returns a bool to show if a Vin is a Coinbase one or not.
func (*Vin) MarshalJSON ¶
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"` Tree int8 `json:"tree"` AmountIn *float64 `json:"amountin,omitempty"` BlockHeight *uint32 `json:"blockheight,omitempty"` BlockIndex *uint32 `json:"blockindex,omitempty"` 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 VoteChoice ¶
type VoteChoice struct { AgendaID string `json:"agendaid"` AgendaDescription string `json:"agendadescription"` ChoiceID string `json:"choiceid"` ChoiceDescription string `json:"choicedescription"` }
VoteChoice models the data for a vote choice in the getvotechoices result.
type VoteCreatedNtfn ¶
type VoteCreatedNtfn struct { TxHash string BlockHash string Height int32 SStxIn string VoteBits uint16 }
VoteCreatedNtfn is a type handling custom marshaling and unmarshaling of ticketpurchased JSON websocket notifications.
func NewVoteCreatedNtfn ¶
func NewVoteCreatedNtfn(txHash string, blockHash string, height int32, sstxIn string, voteBits uint16) *VoteCreatedNtfn
NewVoteCreatedNtfn creates a new VoteCreatedNtfn.
type Vout ¶
type Vout struct { Value float64 `json:"value"` N uint32 `json:"n"` Version uint16 `json:"version"` 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 WalletInfoCmd ¶
type WalletInfoCmd struct { }
WalletInfoCmd defines the walletinfo JSON-RPC command.
func NewWalletInfoCmd ¶
func NewWalletInfoCmd() *WalletInfoCmd
NewWalletInfoCmd returns a new instance which can be used to issue a walletinfo JSON-RPC command.
type WalletInfoResult ¶
type WalletInfoResult struct { DaemonConnected bool `json:"daemonconnected"` Unlocked bool `json:"unlocked"` TxFee float64 `json:"txfee"` TicketFee float64 `json:"ticketfee"` TicketPurchasing bool `json:"ticketpurchasing"` VoteBits uint16 `json:"votebits"` VoteBitsExtended string `json:"votebitsextended"` VoteVersion uint32 `json:"voteversion"` Voting bool `json:"voting"` }
WalletInfoResult models the data returned from the walletinfo command.
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 ¶
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 ¶
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.
type WinningTicketsNtfn ¶
type WinningTicketsNtfn struct { BlockHash string BlockHeight int32 BlockKeyHeight int32 Tickets map[string]string }
WinningTicketsNtfn is a type handling custom marshaling and unmarshaling of blockconnected JSON websocket notifications.
func NewWinningTicketsNtfn ¶
func NewWinningTicketsNtfn(hash string, height int32, keyHeight int32, tickets map[string]string) *WinningTicketsNtfn
NewWinningTicketsNtfn creates a new WinningTicketsNtfn.
Source Files ¶
- btcdextcmds.go
- btcwalletextcmds.go
- chainsvrcmds.go
- chainsvrresults.go
- chainsvrwscmds.go
- chainsvrwsntfns.go
- chainsvrwsresults.go
- cmdinfo.go
- cmdparse.go
- doc.go
- error.go
- hcashdcmds.go
- hcashdresults.go
- hcashwalletextcmds.go
- hcashwalletextresults.go
- hcashwalletextwsntfns.go
- help.go
- helpers.go
- jsonerr.go
- jsonrpc.go
- jsonrpcerr.go
- parse.go
- register.go
- walletsvrcmds.go
- walletsvrresults.go
- walletsvrwscmds.go
- walletsvrwsntfns.go