// Copyright (c) 2013-2017 The btcsuite developers

// Copyright (c) 2015-2017 The Decred developers

// Use of this source code is governed by an ISC

// license that can be found in the LICENSE file.

package main

import (

"bytes"

"crypto/sha256"

"crypto/subtle"

"encoding/base64"

"encoding/hex"

"encoding/json"

"errors"

"fmt"

"io"

"io/ioutil"

"math/big"

"math/rand"

"net"

"net/http"

"os"

"strconv"

"strings"

"sync"

"sync/atomic"

"time"

"github.com/btcsuite/btcd/blockchain"

"github.com/btcsuite/btcd/blockchain/indexers"

"github.com/btcsuite/btcd/btcec/v2/ecdsa"

"github.com/btcsuite/btcd/btcjson"

"github.com/btcsuite/btcd/btcutil"

"github.com/btcsuite/btcd/chaincfg"

"github.com/btcsuite/btcd/chaincfg/chainhash"

"github.com/btcsuite/btcd/database"

"github.com/btcsuite/btcd/mempool"

"github.com/btcsuite/btcd/mining"

"github.com/btcsuite/btcd/mining/cpuminer"

"github.com/btcsuite/btcd/peer"

"github.com/btcsuite/btcd/rpcclient"

"github.com/btcsuite/btcd/txscript"

"github.com/btcsuite/btcd/wire"

"github.com/btcsuite/websocket"

)

// API version constants

const (

jsonrpcSemverString = "1.3.0"

jsonrpcSemverMajor = 1

jsonrpcSemverMinor = 3

jsonrpcSemverPatch = 0

)

const (

// rpcAuthTimeoutSeconds is the number of seconds a connection to the

// RPC server is allowed to stay open without authenticating before it

// is closed.

rpcAuthTimeoutSeconds = 10

// uint256Size is the number of bytes needed to represent an unsigned

// 256-bit integer.

uint256Size = 32

// gbtNonceRange is two 32-bit big-endian hexadecimal integers which

// represent the valid ranges of nonces returned by the getblocktemplate

// RPC.

gbtNonceRange = "00000000ffffffff"

// gbtRegenerateSeconds is the number of seconds that must pass before

// a new template is generated when the previous block hash has not

// changed and there have been changes to the available transactions

// in the memory pool.

gbtRegenerateSeconds = 60

// maxProtocolVersion is the max protocol version the server supports.

maxProtocolVersion = 70002

// defaultMaxFeeRate is the default value to use(0.1 BTC/kvB) when the

// `MaxFee` field is not set when calling `testmempoolaccept`.

defaultMaxFeeRate = 0.1

)

var (

// gbtMutableFields are the manipulations the server allows to be made

// to block templates generated by the getblocktemplate RPC. It is

// declared here to avoid the overhead of creating the slice on every

// invocation for constant data.

gbtMutableFields = []string{

"time", "transactions/add", "prevblock", "coinbase/append",

}

// gbtCoinbaseAux describes additional data that miners should include

// in the coinbase signature script. It is declared here to avoid the

// overhead of creating a new object on every invocation for constant

// data.

gbtCoinbaseAux = &btcjson.GetBlockTemplateResultAux{

Flags: hex.EncodeToString(builderScript(txscript.

NewScriptBuilder().

AddData([]byte(mining.CoinbaseFlags)))),

}

// gbtCapabilities describes additional capabilities returned with a

// block template generated by the getblocktemplate RPC. It is

// declared here to avoid the overhead of creating the slice on every

// invocation for constant data.

gbtCapabilities = []string{"proposal"}

// JSON 2.0 batched request prefix

batchedRequestPrefix = []byte("[")

)

// Errors

var (

// ErrRPCUnimplemented is an error returned to RPC clients when the

// provided command is recognized, but not implemented.

ErrRPCUnimplemented = &btcjson.RPCError{

Code: btcjson.ErrRPCUnimplemented,

Message: "Command unimplemented",

}

// ErrRPCNoWallet is an error returned to RPC clients when the provided

// command is recognized as a wallet command.

ErrRPCNoWallet = &btcjson.RPCError{

Code: btcjson.ErrRPCNoWallet,

Message: "This implementation does not implement wallet commands",

}

)

type commandHandler func(*rpcServer, interface{}, <-chan struct{}) (interface{}, error)

// rpcHandlers maps RPC command strings to appropriate handler functions.

// This is set by init because help references rpcHandlers and thus causes

// a dependency loop.

var rpcHandlers map[string]commandHandler

var rpcHandlersBeforeInit = map[string]commandHandler{

"addnode": handleAddNode,

"createrawtransaction": handleCreateRawTransaction,

"debuglevel": handleDebugLevel,

"decoderawtransaction": handleDecodeRawTransaction,

"decodescript": handleDecodeScript,

"estimatefee": handleEstimateFee,

"generate": handleGenerate,

"getaddednodeinfo": handleGetAddedNodeInfo,

"getbestblock": handleGetBestBlock,

"getbestblockhash": handleGetBestBlockHash,

"getblock": handleGetBlock,

"getblockchaininfo": handleGetBlockChainInfo,

"getblockcount": handleGetBlockCount,

"getblockhash": handleGetBlockHash,

"getblockheader": handleGetBlockHeader,

"getblocktemplate": handleGetBlockTemplate,

"getchaintips": handleGetChainTips,

"getcfilter": handleGetCFilter,

"getcfilterheader": handleGetCFilterHeader,

"getconnectioncount": handleGetConnectionCount,

"getcurrentnet": handleGetCurrentNet,

"getdifficulty": handleGetDifficulty,

"getgenerate": handleGetGenerate,

"gethashespersec": handleGetHashesPerSec,

"getheaders": handleGetHeaders,

"getinfo": handleGetInfo,

"getmempoolinfo": handleGetMempoolInfo,

"getmininginfo": handleGetMiningInfo,

"getnettotals": handleGetNetTotals,

"getnetworkhashps": handleGetNetworkHashPS,

"getnodeaddresses": handleGetNodeAddresses,

"getpeerinfo": handleGetPeerInfo,

"getrawmempool": handleGetRawMempool,

"getrawtransaction": handleGetRawTransaction,

"gettxout": handleGetTxOut,

"help": handleHelp,

"node": handleNode,

"ping": handlePing,

"searchrawtransactions": handleSearchRawTransactions,

"sendrawtransaction": handleSendRawTransaction,

"setgenerate": handleSetGenerate,

"signmessagewithprivkey": handleSignMessageWithPrivKey,

"stop": handleStop,

"submitblock": handleSubmitBlock,

"uptime": handleUptime,

"validateaddress": handleValidateAddress,

"verifychain": handleVerifyChain,

"verifymessage": handleVerifyMessage,

"version": handleVersion,

"testmempoolaccept": handleTestMempoolAccept,

}

// list of commands that we recognize, but for which btcd has no support because

// it lacks support for wallet functionality. For these commands the user

// should ask a connected instance of btcwallet.

var rpcAskWallet = map[string]struct{}{

"addmultisigaddress": {},

"backupwallet": {},

"createencryptedwallet": {},

"createmultisig": {},

"dumpprivkey": {},

"dumpwallet": {},

"encryptwallet": {},

"getaccount": {},

"getaccountaddress": {},

"getaddressesbyaccount": {},

"getbalance": {},

"getnewaddress": {},

"getrawchangeaddress": {},

"getreceivedbyaccount": {},

"getreceivedbyaddress": {},

"gettransaction": {},

"gettxoutsetinfo": {},

"getunconfirmedbalance": {},

"getwalletinfo": {},

"importprivkey": {},

"importwallet": {},

"keypoolrefill": {},

"listaccounts": {},

"listaddressgroupings": {},

"listlockunspent": {},

"listreceivedbyaccount": {},

"listreceivedbyaddress": {},

"listsinceblock": {},

"listtransactions": {},

"listunspent": {},

"lockunspent": {},

"move": {},

"sendfrom": {},

"sendmany": {},

"sendtoaddress": {},

"setaccount": {},

"settxfee": {},

"signmessage": {},

"signrawtransaction": {},

"walletlock": {},

"walletpassphrase": {},

"walletpassphrasechange": {},

}

// Commands that are currently unimplemented, but should ultimately be.

var rpcUnimplemented = map[string]struct{}{

"estimatepriority": {},

"getmempoolentry": {},

"getnetworkinfo": {},

"getwork": {},

"invalidateblock": {},

"preciousblock": {},

"reconsiderblock": {},

}

// Commands that are available to a limited user

var rpcLimited = map[string]struct{}{

// Websockets commands

"loadtxfilter": {},

"notifyblocks": {},

"notifynewtransactions": {},

"notifyreceived": {},

"notifyspent": {},

"rescan": {},

"rescanblocks": {},

"session": {},

// Websockets AND HTTP/S commands

"help": {},

// HTTP/S-only commands

"createrawtransaction": {},

"decoderawtransaction": {},

"decodescript": {},

"estimatefee": {},

"getbestblock": {},

"getbestblockhash": {},

"getblock": {},

"getblockcount": {},

"getblockhash": {},

"getblockheader": {},

"getchaintips": {},

"getcfilter": {},

"getcfilterheader": {},

"getcurrentnet": {},

"getdifficulty": {},

"getheaders": {},

"getinfo": {},

"getnettotals": {},

"getnetworkhashps": {},

"getrawmempool": {},

"getrawtransaction": {},

"gettxout": {},

"searchrawtransactions": {},

"sendrawtransaction": {},

"submitblock": {},

"uptime": {},

"validateaddress": {},

"verifymessage": {},

"version": {},

}

// builderScript is a convenience function which is used for hard-coded scripts

// built with the script builder. Any errors are converted to a panic since it

// is only, and must only, be used with hard-coded, and therefore, known good,

// scripts.

func builderScript(builder *txscript.ScriptBuilder) []byte {

script, err := builder.Script()

if err != nil {

panic(err)

}

return script

}

// internalRPCError is a convenience function to convert an internal error to

// an RPC error with the appropriate code set. It also logs the error to the

// RPC server subsystem since internal errors really should not occur. The

// context parameter is only used in the log message and may be empty if it's

// not needed.

func internalRPCError(errStr, context string) *btcjson.RPCError {

logStr := errStr

if context != "" {

logStr = context + ": " + errStr

}

rpcsLog.Error(logStr)

return btcjson.NewRPCError(btcjson.ErrRPCInternal.Code, errStr)

}

// rpcDecodeHexError is a convenience function for returning a nicely formatted

// RPC error which indicates the provided hex string failed to decode.

func rpcDecodeHexError(gotHex string) *btcjson.RPCError {

return btcjson.NewRPCError(btcjson.ErrRPCDecodeHexString,

fmt.Sprintf("Argument must be hexadecimal string (not %q)",

gotHex))

}

// rpcNoTxInfoError is a convenience function for returning a nicely formatted

// RPC error which indicates there is no information available for the provided

// transaction hash.

func rpcNoTxInfoError(txHash *chainhash.Hash) *btcjson.RPCError {

return btcjson.NewRPCError(btcjson.ErrRPCNoTxInfo,

fmt.Sprintf("No information available about transaction %v",

txHash))

}

// gbtWorkState houses state that is used in between multiple RPC invocations to

// getblocktemplate.

type gbtWorkState struct {

sync.Mutex

lastTxUpdate time.Time

lastGenerated time.Time

prevHash *chainhash.Hash

minTimestamp time.Time

template *mining.BlockTemplate

notifyMap map[chainhash.Hash]map[int64]chan struct{}

timeSource blockchain.MedianTimeSource

}

// newGbtWorkState returns a new instance of a gbtWorkState with all internal

// fields initialized and ready to use.

func newGbtWorkState(timeSource blockchain.MedianTimeSource) *gbtWorkState {

return &gbtWorkState{

notifyMap: make(map[chainhash.Hash]map[int64]chan struct{}),

timeSource: timeSource,

}

}

// handleUnimplemented is the handler for commands that should ultimately be

// supported but are not yet implemented.

func handleUnimplemented(s *rpcServer, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {

return nil, ErrRPCUnimplemented

}

// handleAskWallet is the handler for commands that are recognized as valid, but

// are unable to answer correctly since it involves wallet state.

// These commands will be implemented in btcwallet.

func handleAskWallet(s *rpcServer, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {

return nil, ErrRPCNoWallet

}

// handleAddNode handles addnode commands.

func handleAddNode(s *rpcServer, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {

c := cmd.(*btcjson.AddNodeCmd)

addr := normalizeAddress(c.Addr, s.cfg.ChainParams.DefaultPort)

var err error

switch c.SubCmd {

case "add":

err = s.cfg.ConnMgr.Connect(addr, true)

case "remove":

err = s.cfg.ConnMgr.RemoveByAddr(addr)

case "onetry":

err = s.cfg.ConnMgr.Connect(addr, false)

default:

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCInvalidParameter,

Message: "invalid subcommand for addnode",

}

}

if err != nil {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCInvalidParameter,

Message: err.Error(),

}

}

// no data returned unless an error.

return nil, nil

}

// handleNode handles node commands.

func handleNode(s *rpcServer, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {

c := cmd.(*btcjson.NodeCmd)

var addr string

var nodeID uint64

var errN, err error

params := s.cfg.ChainParams

switch c.SubCmd {

case "disconnect":

// If we have a valid uint disconnect by node id. Otherwise,

// attempt to disconnect by address, returning an error if a

// valid IP address is not supplied.

if nodeID, errN = strconv.ParseUint(c.Target, 10, 32); errN == nil {

err = s.cfg.ConnMgr.DisconnectByID(int32(nodeID))

} else {

if _, _, errP := net.SplitHostPort(c.Target); errP == nil || net.ParseIP(c.Target) != nil {

addr = normalizeAddress(c.Target, params.DefaultPort)

err = s.cfg.ConnMgr.DisconnectByAddr(addr)

} else {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCInvalidParameter,

Message: "invalid address or node ID",

}

}

}

if err != nil && peerExists(s.cfg.ConnMgr, addr, int32(nodeID)) {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCMisc,

Message: "can't disconnect a permanent peer, use remove",

}

}

case "remove":

// If we have a valid uint disconnect by node id. Otherwise,

// attempt to disconnect by address, returning an error if a

// valid IP address is not supplied.

if nodeID, errN = strconv.ParseUint(c.Target, 10, 32); errN == nil {

err = s.cfg.ConnMgr.RemoveByID(int32(nodeID))

} else {

if _, _, errP := net.SplitHostPort(c.Target); errP == nil || net.ParseIP(c.Target) != nil {

addr = normalizeAddress(c.Target, params.DefaultPort)

err = s.cfg.ConnMgr.RemoveByAddr(addr)

} else {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCInvalidParameter,

Message: "invalid address or node ID",

}

}

}

if err != nil && peerExists(s.cfg.ConnMgr, addr, int32(nodeID)) {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCMisc,

Message: "can't remove a temporary peer, use disconnect",

}

}

case "connect":

addr = normalizeAddress(c.Target, params.DefaultPort)

// Default to temporary connections.

subCmd := "temp"

if c.ConnectSubCmd != nil {

subCmd = *c.ConnectSubCmd

}

switch subCmd {

case "perm", "temp":

err = s.cfg.ConnMgr.Connect(addr, subCmd == "perm")

default:

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCInvalidParameter,

Message: "invalid subcommand for node connect",

}

}

default:

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCInvalidParameter,

Message: "invalid subcommand for node",

}

}

if err != nil {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCInvalidParameter,

Message: err.Error(),

}

}

// no data returned unless an error.

return nil, nil

}

// peerExists determines if a certain peer is currently connected given

// information about all currently connected peers. Peer existence is

// determined using either a target address or node id.

func peerExists(connMgr rpcserverConnManager, addr string, nodeID int32) bool {

for _, p := range connMgr.ConnectedPeers() {

if p.ToPeer().ID() == nodeID || p.ToPeer().Addr() == addr {

return true

}

}

return false

}

// messageToHex serializes a message to the wire protocol encoding using the

// latest protocol version and returns a hex-encoded string of the result.

func messageToHex(msg wire.Message) (string, error) {

var buf bytes.Buffer

if err := msg.BtcEncode(&buf, maxProtocolVersion, wire.WitnessEncoding); err != nil {

context := fmt.Sprintf("Failed to encode msg of type %T", msg)

return "", internalRPCError(err.Error(), context)

}

return hex.EncodeToString(buf.Bytes()), nil

}

// handleCreateRawTransaction handles createrawtransaction commands.

func handleCreateRawTransaction(s *rpcServer, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {

c := cmd.(*btcjson.CreateRawTransactionCmd)

// Validate the locktime, if given.

if c.LockTime != nil &&

(*c.LockTime < 0 || *c.LockTime > int64(wire.MaxTxInSequenceNum)) {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCInvalidParameter,

Message: "Locktime out of range",

}

}

// Add all transaction inputs to a new transaction after performing

// some validity checks.

mtx := wire.NewMsgTx(wire.TxVersion)

for _, input := range c.Inputs {

txHash, err := chainhash.NewHashFromStr(input.Txid)

if err != nil {

return nil, rpcDecodeHexError(input.Txid)

}

prevOut := wire.NewOutPoint(txHash, input.Vout)

txIn := wire.NewTxIn(prevOut, []byte{}, nil)

if c.LockTime != nil && *c.LockTime != 0 {

txIn.Sequence = wire.MaxTxInSequenceNum - 1

}

mtx.AddTxIn(txIn)

}

// Add all transaction outputs to the transaction after performing

// some validity checks.

params := s.cfg.ChainParams

for encodedAddr, amount := range c.Amounts {

// Ensure amount is in the valid range for monetary amounts.

if amount <= 0 || amount*btcutil.SatoshiPerBitcoin > btcutil.MaxSatoshi {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCType,

Message: "Invalid amount",

}

}

// Decode the provided address.

addr, err := btcutil.DecodeAddress(encodedAddr, params)

if err != nil {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCInvalidAddressOrKey,

Message: "Invalid address or key: " + err.Error(),

}

}

// Ensure the address is one of the supported types and that

// the network encoded with the address matches the network the

// server is currently on.

switch addr.(type) {

case *btcutil.AddressPubKeyHash:

case *btcutil.AddressScriptHash:

default:

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCInvalidAddressOrKey,

Message: "Invalid address or key",

}

}

if !addr.IsForNet(params) {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCInvalidAddressOrKey,

Message: "Invalid address: " + encodedAddr +

" is for the wrong network",

}

}

// Create a new script which pays to the provided address.

pkScript, err := txscript.PayToAddrScript(addr)

if err != nil {

context := "Failed to generate pay-to-address script"

return nil, internalRPCError(err.Error(), context)

}

// Convert the amount to satoshi.

satoshi, err := btcutil.NewAmount(amount)

if err != nil {

context := "Failed to convert amount"

return nil, internalRPCError(err.Error(), context)

}

txOut := wire.NewTxOut(int64(satoshi), pkScript)

mtx.AddTxOut(txOut)

}

// Set the Locktime, if given.

if c.LockTime != nil {

mtx.LockTime = uint32(*c.LockTime)

}

// Return the serialized and hex-encoded transaction. Note that this

// is intentionally not directly returning because the first return

// value is a string and it would result in returning an empty string to

// the client instead of nothing (nil) in the case of an error.

mtxHex, err := messageToHex(mtx)

if err != nil {

return nil, err

}

return mtxHex, nil

}

// handleDebugLevel handles debuglevel commands.

func handleDebugLevel(s *rpcServer, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {

c := cmd.(*btcjson.DebugLevelCmd)

// Special show command to list supported subsystems.

if c.LevelSpec == "show" {

return fmt.Sprintf("Supported subsystems %v",

supportedSubsystems()), nil

}

err := parseAndSetDebugLevels(c.LevelSpec)

if err != nil {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCInvalidParams.Code,

Message: err.Error(),

}

}

return "Done.", nil

}

// witnessToHex formats the passed witness stack as a slice of hex-encoded

// strings to be used in a JSON response.

func witnessToHex(witness wire.TxWitness) []string {

// Ensure nil is returned when there are no entries versus an empty

// slice so it can properly be omitted as necessary.

if len(witness) == 0 {

return nil

}

result := make([]string, 0, len(witness))

for _, wit := range witness {

result = append(result, hex.EncodeToString(wit))

}

return result

}

// createVinList returns a slice of JSON objects for the inputs of the passed

// transaction.

func createVinList(mtx *wire.MsgTx) []btcjson.Vin {

// Coinbase transactions only have a single txin by definition.

vinList := make([]btcjson.Vin, len(mtx.TxIn))

if blockchain.IsCoinBaseTx(mtx) {

txIn := mtx.TxIn[0]

vinList[0].Coinbase = hex.EncodeToString(txIn.SignatureScript)

vinList[0].Sequence = txIn.Sequence

vinList[0].Witness = witnessToHex(txIn.Witness)

return vinList

}

for i, txIn := range mtx.TxIn {

// The disassembled string will contain [error] inline

// if the script doesn't fully parse, so ignore the

// error here.

disbuf, _ := txscript.DisasmString(txIn.SignatureScript)

vinEntry := &vinList[i]

vinEntry.Txid = txIn.PreviousOutPoint.Hash.String()

vinEntry.Vout = txIn.PreviousOutPoint.Index

vinEntry.Sequence = txIn.Sequence

vinEntry.ScriptSig = &btcjson.ScriptSig{

Asm: disbuf,

Hex: hex.EncodeToString(txIn.SignatureScript),

}

if mtx.HasWitness() {

vinEntry.Witness = witnessToHex(txIn.Witness)

}

}

return vinList

}

// createVoutList returns a slice of JSON objects for the outputs of the passed

// transaction.

func createVoutList(mtx *wire.MsgTx, chainParams *chaincfg.Params, filterAddrMap map[string]struct{}) []btcjson.Vout {

voutList := make([]btcjson.Vout, 0, len(mtx.TxOut))

for i, v := range mtx.TxOut {

// The disassembled string will contain [error] inline if the

// script doesn't fully parse, so ignore the error here.

disbuf, _ := txscript.DisasmString(v.PkScript)

// Ignore the error here since an error means the script

// couldn't parse and there is no additional information about

// it anyways.

scriptClass, addrs, reqSigs, _ := txscript.ExtractPkScriptAddrs(

v.PkScript, chainParams)

// Encode the addresses while checking if the address passes the

// filter when needed.

passesFilter := len(filterAddrMap) == 0

encodedAddrs := make([]string, len(addrs))

for j, addr := range addrs {

encodedAddr := addr.EncodeAddress()

encodedAddrs[j] = encodedAddr

// No need to check the map again if the filter already

// passes.

if passesFilter {

continue

}

if _, exists := filterAddrMap[encodedAddr]; exists {

passesFilter = true

}

}

if !passesFilter {

continue

}

var vout btcjson.Vout

vout.N = uint32(i)

vout.Value = btcutil.Amount(v.Value).ToBTC()

vout.ScriptPubKey.Addresses = encodedAddrs

vout.ScriptPubKey.Asm = disbuf

vout.ScriptPubKey.Hex = hex.EncodeToString(v.PkScript)

vout.ScriptPubKey.Type = scriptClass.String()

vout.ScriptPubKey.ReqSigs = int32(reqSigs)

// Address is defined when there's a single well-defined

// receiver address. To spend the output a signature for this,

// and only this, address is required.

if len(encodedAddrs) == 1 && reqSigs <= 1 {

vout.ScriptPubKey.Address = encodedAddrs[0]

}

voutList = append(voutList, vout)

}

return voutList

}

// createTxRawResult converts the passed transaction and associated parameters

// to a raw transaction JSON object.

func createTxRawResult(chainParams *chaincfg.Params, mtx *wire.MsgTx,

txHash string, blkHeader *wire.BlockHeader, blkHash string,

blkHeight int32, chainHeight int32) (*btcjson.TxRawResult, error) {

mtxHex, err := messageToHex(mtx)

if err != nil {

return nil, err

}

txReply := &btcjson.TxRawResult{

Hex: mtxHex,

Txid: txHash,

Hash: mtx.WitnessHash().String(),

Size: int32(mtx.SerializeSize()),

Vsize: int32(mempool.GetTxVirtualSize(btcutil.NewTx(mtx))),

Weight: int32(blockchain.GetTransactionWeight(btcutil.NewTx(mtx))),

Vin: createVinList(mtx),

Vout: createVoutList(mtx, chainParams, nil),

Version: uint32(mtx.Version),

LockTime: mtx.LockTime,

}

if blkHeader != nil {

// This is not a typo, they are identical in bitcoind as well.

txReply.Time = blkHeader.Timestamp.Unix()

txReply.Blocktime = blkHeader.Timestamp.Unix()

txReply.BlockHash = blkHash

txReply.Confirmations = uint64(1 + chainHeight - blkHeight)

}

return txReply, nil

}

// handleDecodeRawTransaction handles decoderawtransaction commands.

func handleDecodeRawTransaction(s *rpcServer, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {

c := cmd.(*btcjson.DecodeRawTransactionCmd)

// Deserialize the transaction.

hexStr := c.HexTx

if len(hexStr)%2 != 0 {

hexStr = "0" + hexStr

}

serializedTx, err := hex.DecodeString(hexStr)

if err != nil {

return nil, rpcDecodeHexError(hexStr)

}

var mtx wire.MsgTx

err = mtx.Deserialize(bytes.NewReader(serializedTx))

if err != nil {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCDeserialization,

Message: "TX decode failed: " + err.Error(),

}

}

// Create and return the result.

txReply := btcjson.TxRawDecodeResult{

Txid: mtx.TxHash().String(),

Version: mtx.Version,

Locktime: mtx.LockTime,

Vin: createVinList(&mtx),

Vout: createVoutList(&mtx, s.cfg.ChainParams, nil),

}

return txReply, nil

}

// handleDecodeScript handles decodescript commands.

func handleDecodeScript(s *rpcServer, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {

c := cmd.(*btcjson.DecodeScriptCmd)

// Convert the hex script to bytes.

hexStr := c.HexScript

if len(hexStr)%2 != 0 {

hexStr = "0" + hexStr

}

script, err := hex.DecodeString(hexStr)

if err != nil {

return nil, rpcDecodeHexError(hexStr)

}

// The disassembled string will contain [error] inline if the script

// doesn't fully parse, so ignore the error here.

disbuf, _ := txscript.DisasmString(script)

// Get information about the script.

// Ignore the error here since an error means the script couldn't parse

// and there is no additinal information about it anyways.

scriptClass, addrs, reqSigs, _ := txscript.ExtractPkScriptAddrs(script,

s.cfg.ChainParams)

addresses := make([]string, len(addrs))

for i, addr := range addrs {

addresses[i] = addr.EncodeAddress()

}

// Convert the script itself to a pay-to-script-hash address.

p2sh, err := btcutil.NewAddressScriptHash(script, s.cfg.ChainParams)

if err != nil {

context := "Failed to convert script to pay-to-script-hash"

return nil, internalRPCError(err.Error(), context)

}

// Generate and return the reply.

reply := btcjson.DecodeScriptResult{

Asm: disbuf,

ReqSigs: int32(reqSigs),

Type: scriptClass.String(),

Addresses: addresses,

}

if scriptClass != txscript.ScriptHashTy {

reply.P2sh = p2sh.EncodeAddress()

}

// Address is defined when there's a single well-defined

// receiver address. To spend the output a signature for this,

// and only this, address is required.

if len(addresses) == 1 && reqSigs <= 1 {

reply.Address = addresses[0]

}

return reply, nil

}

// handleEstimateFee handles estimatefee commands.

func handleEstimateFee(s *rpcServer, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {

c := cmd.(*btcjson.EstimateFeeCmd)

if s.cfg.FeeEstimator == nil {

return nil, errors.New("Fee estimation disabled")

}

if c.NumBlocks <= 0 {

return -1.0, errors.New("Parameter NumBlocks must be positive")

}

feeRate, err := s.cfg.FeeEstimator.EstimateFee(uint32(c.NumBlocks))

if err != nil {

return -1.0, err

}

// Convert to satoshis per kb.

return float64(feeRate), nil

}

// handleGenerate handles generate commands.

func handleGenerate(s *rpcServer, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {

// Respond with an error if there are no addresses to pay the

// created blocks to.

if len(cfg.miningAddrs) == 0 {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCInternal.Code,

Message: "No payment addresses specified " +

"via --miningaddr",

}

}

// Respond with an error if there's virtually 0 chance of mining a block

// with the CPU.

if !s.cfg.ChainParams.GenerateSupported {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCDifficulty,

Message: fmt.Sprintf("No support for `generate` on "+

"the current network, %s, as it's unlikely to "+

"be possible to mine a block with the CPU.",

s.cfg.ChainParams.Net),

}

}

c := cmd.(*btcjson.GenerateCmd)

// Respond with an error if the client is requesting 0 blocks to be generated.

if c.NumBlocks == 0 {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCInternal.Code,

Message: "Please request a nonzero number of blocks to generate.",

}

}

// Create a reply

reply := make([]string, c.NumBlocks)

blockHashes, err := s.cfg.CPUMiner.GenerateNBlocks(c.NumBlocks)

if err != nil {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCInternal.Code,

Message: err.Error(),

}

}

// Mine the correct number of blocks, assigning the hex representation of the

// hash of each one to its place in the reply.

for i, hash := range blockHashes {

reply[i] = hash.String()

}

return reply, nil

}

// handleGetAddedNodeInfo handles getaddednodeinfo commands.

func handleGetAddedNodeInfo(s *rpcServer, cmd interface{}, closeChan <-chan struct{}) (interface{}, error) {

c := cmd.(*btcjson.GetAddedNodeInfoCmd)

// Retrieve a list of persistent (added) peers from the server and

// filter the list of peers per the specified address (if any).

peers := s.cfg.ConnMgr.PersistentPeers()

if c.Node != nil {

node := *c.Node

found := false

for i, peer := range peers {

if peer.ToPeer().Addr() == node {

peers = peers[i : i+1]

found = true

}

}

if !found {

return nil, &btcjson.RPCError{

Code: btcjson.ErrRPCClientNodeNotAdded,

Message: "Node has not been added",

}

}

}

// Without the dns flag, the result is just a slice of the addresses as

// strings.

if !c.DNS {

results := make([]string, 0, len(peers))

for _, peer := range peers {

results = append(results, peer.ToPeer().Addr())

}

return results, nil

}

// With the dns flag, the result is an array of JSON objects which

// include the result of DNS lookups for each peer.

results := make([]*btcjson.GetAddedNodeInfoResult, 0, len(peers))

for _, rpcPeer := range peers {

// Set the "address" of the peer which could be an ip address

// or a domain name.

peer := rpcPeer.ToPeer()