7ca16dfe70
The responses chan for a websocket client was being closed by one of the websocket goroutines, but it was not the only sender to this channel. There was also the notification handler, run by the server to handle notifications to all websocket clients. It was possible to hit cases where sends to this channel would still occur (the select statement doesn't guarantee that the picked channel operation won't panic, even if there's another that won't). To fix this, wait on the client being removed from the notification group, or if the server is already shutting down, wait on the notification handler completely closing, to ensure that no more sends to the channel will occur, before closing the channel. Fixes #110.
2968 lines
85 KiB
Go
2968 lines
85 KiB
Go
/*
|
|
* Copyright (c) 2013, 2014 Conformal Systems LLC <info@conformal.com>
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/ecdsa"
|
|
"crypto/sha256"
|
|
"crypto/subtle"
|
|
"crypto/tls"
|
|
"encoding/base64"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
"github.com/conformal/btcec"
|
|
"github.com/conformal/btcjson"
|
|
"github.com/conformal/btcrpcclient"
|
|
"github.com/conformal/btcscript"
|
|
"github.com/conformal/btcutil"
|
|
"github.com/conformal/btcwallet/keystore"
|
|
"github.com/conformal/btcwallet/txstore"
|
|
"github.com/conformal/btcwire"
|
|
"github.com/conformal/btcws"
|
|
"github.com/conformal/websocket"
|
|
)
|
|
|
|
// Error types to simplify the reporting of specific categories of
|
|
// errors, and their btcjson.Error creation.
|
|
type (
|
|
// DeserializationError describes a failed deserializaion due to bad
|
|
// user input. It cooresponds to btcjson.ErrDeserialization.
|
|
DeserializationError struct {
|
|
error
|
|
}
|
|
|
|
// InvalidParameterError describes an invalid parameter passed by
|
|
// the user. It cooresponds to btcjson.ErrInvalidParameter.
|
|
InvalidParameterError struct {
|
|
error
|
|
}
|
|
|
|
// ParseError describes a failed parse due to bad user input. It
|
|
// cooresponds to btcjson.ErrParse.
|
|
ParseError struct {
|
|
error
|
|
}
|
|
|
|
// InvalidAddressOrKeyError describes a parse, network mismatch, or
|
|
// missing address error when decoding or validating an address or
|
|
// key. It cooresponds to btcjson.ErrInvalidAddressOrKey.
|
|
InvalidAddressOrKeyError struct {
|
|
error
|
|
}
|
|
)
|
|
|
|
// Errors variables that are defined once here to avoid duplication below.
|
|
var (
|
|
ErrNeedPositiveAmount = InvalidParameterError{
|
|
errors.New("amount must be positive"),
|
|
}
|
|
|
|
ErrNeedPositiveMinconf = InvalidParameterError{
|
|
errors.New("minconf must be positive"),
|
|
}
|
|
|
|
ErrAddressNotInWallet = InvalidAddressOrKeyError{
|
|
errors.New("address not found in wallet"),
|
|
}
|
|
)
|
|
|
|
type websocketClient struct {
|
|
conn *websocket.Conn
|
|
authenticated bool
|
|
remoteAddr string
|
|
allRequests chan []byte
|
|
unauthedRequests chan unauthedRequest
|
|
responses chan []byte
|
|
quit chan struct{} // closed on disconnect
|
|
}
|
|
|
|
func newWebsocketClient(c *websocket.Conn, authenticated bool, remoteAddr string) *websocketClient {
|
|
return &websocketClient{
|
|
conn: c,
|
|
authenticated: authenticated,
|
|
remoteAddr: remoteAddr,
|
|
allRequests: make(chan []byte),
|
|
unauthedRequests: make(chan unauthedRequest, maxConcurrentClientRequests),
|
|
responses: make(chan []byte),
|
|
quit: make(chan struct{}),
|
|
}
|
|
}
|
|
|
|
var errDisconnected = errors.New("websocket client disconnected")
|
|
|
|
func (c *websocketClient) send(b []byte) error {
|
|
select {
|
|
case c.responses <- b:
|
|
return nil
|
|
case <-c.quit:
|
|
return errDisconnected
|
|
}
|
|
}
|
|
|
|
// parseListeners splits the list of listen addresses passed in addrs into
|
|
// IPv4 and IPv6 slices and returns them. This allows easy creation of the
|
|
// listeners on the correct interface "tcp4" and "tcp6". It also properly
|
|
// detects addresses which apply to "all interfaces" and adds the address to
|
|
// both slices.
|
|
func parseListeners(addrs []string) ([]string, []string, error) {
|
|
ipv4ListenAddrs := make([]string, 0, len(addrs)*2)
|
|
ipv6ListenAddrs := make([]string, 0, len(addrs)*2)
|
|
for _, addr := range addrs {
|
|
host, _, err := net.SplitHostPort(addr)
|
|
if err != nil {
|
|
// Shouldn't happen due to already being normalized.
|
|
return nil, nil, err
|
|
}
|
|
|
|
// Empty host or host of * on plan9 is both IPv4 and IPv6.
|
|
if host == "" || (host == "*" && runtime.GOOS == "plan9") {
|
|
ipv4ListenAddrs = append(ipv4ListenAddrs, addr)
|
|
ipv6ListenAddrs = append(ipv6ListenAddrs, addr)
|
|
continue
|
|
}
|
|
|
|
// Parse the IP.
|
|
ip := net.ParseIP(host)
|
|
if ip == nil {
|
|
return nil, nil, fmt.Errorf("'%s' is not a valid IP "+
|
|
"address", host)
|
|
}
|
|
|
|
// To4 returns nil when the IP is not an IPv4 address, so use
|
|
// this determine the address type.
|
|
if ip.To4() == nil {
|
|
ipv6ListenAddrs = append(ipv6ListenAddrs, addr)
|
|
} else {
|
|
ipv4ListenAddrs = append(ipv4ListenAddrs, addr)
|
|
}
|
|
}
|
|
return ipv4ListenAddrs, ipv6ListenAddrs, nil
|
|
}
|
|
|
|
// genCertPair generates a key/cert pair to the paths provided.
|
|
func genCertPair(certFile, keyFile string) error {
|
|
log.Infof("Generating TLS certificates...")
|
|
|
|
// Create directories for cert and key files if they do not yet exist.
|
|
certDir, _ := filepath.Split(certFile)
|
|
keyDir, _ := filepath.Split(keyFile)
|
|
if err := os.MkdirAll(certDir, 0700); err != nil {
|
|
return err
|
|
}
|
|
if err := os.MkdirAll(keyDir, 0700); err != nil {
|
|
return err
|
|
}
|
|
|
|
// Generate cert pair.
|
|
org := "btcwallet autogenerated cert"
|
|
validUntil := time.Now().Add(10 * 365 * 24 * time.Hour)
|
|
cert, key, err := btcutil.NewTLSCertPair(org, validUntil, nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Write cert and key files.
|
|
if err = ioutil.WriteFile(certFile, cert, 0666); err != nil {
|
|
return err
|
|
}
|
|
if err = ioutil.WriteFile(keyFile, key, 0600); err != nil {
|
|
if rmErr := os.Remove(certFile); rmErr != nil {
|
|
log.Warnf("Cannot remove written certificates: %v", rmErr)
|
|
}
|
|
return err
|
|
}
|
|
|
|
log.Info("Done generating TLS certificates")
|
|
return nil
|
|
}
|
|
|
|
// rpcServer holds the items the RPC server may need to access (auth,
|
|
// config, shutdown, etc.)
|
|
type rpcServer struct {
|
|
wg sync.WaitGroup
|
|
maxClients int64 // Maximum number of concurrent active RPC HTTP clients
|
|
maxWebsockets int64 // Maximum number of concurrent active RPC WS clients
|
|
listeners []net.Listener
|
|
authsha [sha256.Size]byte
|
|
wsClients map[*websocketClient]struct{}
|
|
|
|
upgrader websocket.Upgrader
|
|
|
|
requests chan handlerJob
|
|
|
|
addWSClient chan *websocketClient
|
|
removeWSClient chan *websocketClient
|
|
broadcasts chan []byte
|
|
notificationHandlerQuit chan struct{}
|
|
|
|
quit chan struct{}
|
|
}
|
|
|
|
// newRPCServer creates a new server for serving RPC client connections, both
|
|
// HTTP POST and websocket.
|
|
func newRPCServer(listenAddrs []string, maxClients, maxWebsockets int64) (*rpcServer, error) {
|
|
login := cfg.Username + ":" + cfg.Password
|
|
auth := "Basic " + base64.StdEncoding.EncodeToString([]byte(login))
|
|
s := rpcServer{
|
|
authsha: sha256.Sum256([]byte(auth)),
|
|
maxClients: maxClients,
|
|
maxWebsockets: maxWebsockets,
|
|
wsClients: map[*websocketClient]struct{}{},
|
|
upgrader: websocket.Upgrader{
|
|
// Allow all origins.
|
|
CheckOrigin: func(r *http.Request) bool { return true },
|
|
},
|
|
requests: make(chan handlerJob),
|
|
addWSClient: make(chan *websocketClient),
|
|
removeWSClient: make(chan *websocketClient),
|
|
broadcasts: make(chan []byte),
|
|
notificationHandlerQuit: make(chan struct{}),
|
|
quit: make(chan struct{}),
|
|
}
|
|
|
|
// Check for existence of cert file and key file
|
|
if !fileExists(cfg.RPCKey) && !fileExists(cfg.RPCCert) {
|
|
// if both files do not exist, we generate them.
|
|
err := genCertPair(cfg.RPCCert, cfg.RPCKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
keypair, err := tls.LoadX509KeyPair(cfg.RPCCert, cfg.RPCKey)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
tlsConfig := tls.Config{
|
|
Certificates: []tls.Certificate{keypair},
|
|
}
|
|
|
|
ipv4ListenAddrs, ipv6ListenAddrs, err := parseListeners(listenAddrs)
|
|
listeners := make([]net.Listener, 0,
|
|
len(ipv6ListenAddrs)+len(ipv4ListenAddrs))
|
|
for _, addr := range ipv4ListenAddrs {
|
|
listener, err := tls.Listen("tcp4", addr, &tlsConfig)
|
|
if err != nil {
|
|
log.Warnf("RPCS: Can't listen on %s: %v", addr,
|
|
err)
|
|
continue
|
|
}
|
|
listeners = append(listeners, listener)
|
|
}
|
|
|
|
for _, addr := range ipv6ListenAddrs {
|
|
listener, err := tls.Listen("tcp6", addr, &tlsConfig)
|
|
if err != nil {
|
|
log.Warnf("RPCS: Can't listen on %s: %v", addr,
|
|
err)
|
|
continue
|
|
}
|
|
listeners = append(listeners, listener)
|
|
}
|
|
if len(listeners) == 0 {
|
|
return nil, errors.New("no valid listen address")
|
|
}
|
|
|
|
s.listeners = listeners
|
|
|
|
return &s, nil
|
|
}
|
|
|
|
// Start starts a HTTP server to provide standard RPC and extension
|
|
// websocket connections for any number of btcwallet clients.
|
|
func (s *rpcServer) Start() {
|
|
// A duplicator for notifications intended for all clients runs
|
|
// in another goroutines. Any such notifications are sent to
|
|
// the allClients channel and then sent to each connected client.
|
|
s.wg.Add(2)
|
|
go s.NotificationHandler()
|
|
go s.RequestHandler()
|
|
|
|
log.Trace("Starting RPC server")
|
|
|
|
serveMux := http.NewServeMux()
|
|
const rpcAuthTimeoutSeconds = 10
|
|
|
|
httpServer := &http.Server{
|
|
Handler: serveMux,
|
|
|
|
// Timeout connections which don't complete the initial
|
|
// handshake within the allowed timeframe.
|
|
ReadTimeout: time.Second * rpcAuthTimeoutSeconds,
|
|
}
|
|
|
|
serveMux.Handle("/",
|
|
throttledFn(s.maxClients, func(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Connection", "close")
|
|
w.Header().Set("Content-Type", "application/json")
|
|
r.Close = true
|
|
|
|
if err := s.checkAuthHeader(r); err != nil {
|
|
log.Warnf("Unauthorized client connection attempt")
|
|
http.Error(w, "401 Unauthorized.", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
s.PostClientRPC(w, r)
|
|
}),
|
|
)
|
|
|
|
serveMux.Handle("/ws",
|
|
throttledFn(s.maxWebsockets, func(w http.ResponseWriter, r *http.Request) {
|
|
authenticated := false
|
|
switch s.checkAuthHeader(r) {
|
|
case nil:
|
|
authenticated = true
|
|
case ErrNoAuth:
|
|
// nothing
|
|
default:
|
|
// If auth was supplied but incorrect, rather than simply
|
|
// being missing, immediately terminate the connection.
|
|
log.Warnf("Disconnecting improperly authorized " +
|
|
"websocket client")
|
|
http.Error(w, "401 Unauthorized.", http.StatusUnauthorized)
|
|
return
|
|
}
|
|
|
|
conn, err := s.upgrader.Upgrade(w, r, nil)
|
|
if err != nil {
|
|
log.Warnf("Cannot websocket upgrade client %s: %v",
|
|
r.RemoteAddr, err)
|
|
return
|
|
}
|
|
wsc := newWebsocketClient(conn, authenticated, r.RemoteAddr)
|
|
s.WebsocketClientRPC(wsc)
|
|
}),
|
|
)
|
|
|
|
for _, listener := range s.listeners {
|
|
s.wg.Add(1)
|
|
go func(listener net.Listener) {
|
|
log.Infof("RPCS: RPC server listening on %s", listener.Addr())
|
|
_ = httpServer.Serve(listener)
|
|
log.Tracef("RPCS: RPC listener done for %s", listener.Addr())
|
|
s.wg.Done()
|
|
}(listener)
|
|
}
|
|
}
|
|
|
|
// Stop gracefully shuts down the rpc server by stopping and disconnecting all
|
|
// clients, disconnecting the chain server connection, and closing the wallet's
|
|
// account files.
|
|
func (s *rpcServer) Stop() {
|
|
// If the server is changed to run more than one rpc handler at a time,
|
|
// to prevent a double channel close, this should be replaced with an
|
|
// atomic test-and-set.
|
|
select {
|
|
case <-s.quit:
|
|
log.Warnf("Server already shutting down")
|
|
return
|
|
default:
|
|
}
|
|
|
|
log.Warn("Server shutting down")
|
|
|
|
// Stop all the listeners. There will not be any listeners if
|
|
// listening is disabled.
|
|
for _, listener := range s.listeners {
|
|
err := listener.Close()
|
|
if err != nil {
|
|
log.Errorf("Cannot close listener %s: %v",
|
|
listener.Addr(), err)
|
|
}
|
|
}
|
|
|
|
// Disconnect the connected chain server, if any.
|
|
rpcc, err := accessClient()
|
|
if err == nil {
|
|
rpcc.Stop()
|
|
}
|
|
|
|
// Stop the account manager and finish all pending account file writes.
|
|
AcctMgr.Stop()
|
|
|
|
// Signal the remaining goroutines to stop.
|
|
close(s.quit)
|
|
}
|
|
|
|
func (s *rpcServer) WaitForShutdown() {
|
|
AcctMgr.WaitForShutdown()
|
|
s.wg.Wait()
|
|
}
|
|
|
|
// ErrNoAuth represents an error where authentication could not succeed
|
|
// due to a missing Authorization HTTP header.
|
|
var ErrNoAuth = errors.New("no auth")
|
|
|
|
// checkAuthHeader checks the HTTP Basic authentication supplied by a client
|
|
// in the HTTP request r. It errors with ErrNoAuth if the request does not
|
|
// contain the Authorization header, or another non-nil error if the
|
|
// authentication was provided but incorrect.
|
|
//
|
|
// This check is time-constant.
|
|
func (s *rpcServer) checkAuthHeader(r *http.Request) error {
|
|
authhdr := r.Header["Authorization"]
|
|
if len(authhdr) == 0 {
|
|
return ErrNoAuth
|
|
}
|
|
|
|
authsha := sha256.Sum256([]byte(authhdr[0]))
|
|
cmp := subtle.ConstantTimeCompare(authsha[:], s.authsha[:])
|
|
if cmp != 1 {
|
|
return errors.New("bad auth")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// throttledFn wraps an http.HandlerFunc with throttling of concurrent active
|
|
// clients by responding with an HTTP 429 when the threshold is crossed.
|
|
func throttledFn(threshold int64, f http.HandlerFunc) http.Handler {
|
|
return throttled(threshold, f)
|
|
}
|
|
|
|
// throttled wraps an http.Handler with throttling of concurrent active
|
|
// clients by responding with an HTTP 429 when the threshold is crossed.
|
|
func throttled(threshold int64, h http.Handler) http.Handler {
|
|
var active int64
|
|
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
current := atomic.AddInt64(&active, 1)
|
|
defer atomic.AddInt64(&active, -1)
|
|
|
|
if current-1 >= threshold {
|
|
log.Warnf("Reached threshold of %d concurrent active clients", threshold)
|
|
http.Error(w, "429 Too Many Requests", 429)
|
|
return
|
|
}
|
|
|
|
h.ServeHTTP(w, r)
|
|
})
|
|
}
|
|
|
|
func (s *rpcServer) WebsocketClientRead(wsc *websocketClient) {
|
|
for {
|
|
_, request, err := wsc.conn.ReadMessage()
|
|
if err != nil {
|
|
if err != io.EOF && err != io.ErrUnexpectedEOF {
|
|
log.Warnf("Websocket receive failed from client %s: %v",
|
|
wsc.remoteAddr, err)
|
|
}
|
|
close(wsc.allRequests)
|
|
break
|
|
}
|
|
wsc.allRequests <- request
|
|
}
|
|
}
|
|
|
|
type rawRequest struct {
|
|
// "jsonrpc" value isn't checked so we exclude it.
|
|
ID interface{} `json:"id"`
|
|
Method string `json:"method"`
|
|
Params []json.RawMessage `json:"params"`
|
|
}
|
|
|
|
// idPointer returns a pointer to the passed ID, or nil if the interface is nil.
|
|
// Interface pointers are usually a red flag of doing something incorrectly,
|
|
// but this is only implemented here to work around an oddity with btcjson,
|
|
// which uses empty interface pointers for request and response IDs.
|
|
func idPointer(id interface{}) (p *interface{}) {
|
|
if id != nil {
|
|
p = &id
|
|
}
|
|
return
|
|
}
|
|
|
|
func marshalError(id *interface{}) []byte {
|
|
response := btcjson.Reply{
|
|
Id: id,
|
|
Error: &btcjson.ErrInvalidRequest,
|
|
}
|
|
mresponse, err := json.Marshal(response)
|
|
// We expect the marshal to succeed. If it doesn't, it indicates some
|
|
// non-marshalable type in the response.
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return mresponse
|
|
}
|
|
|
|
// websocketPassthrough pass a websocket client's raw request to the connected
|
|
// chain server.
|
|
func (s *rpcServer) websocketPassthrough(wsc *websocketClient, request rawRequest) {
|
|
resp := passthrough(request)
|
|
_ = wsc.send(resp)
|
|
}
|
|
|
|
// postPassthrough pass a websocket client's raw request to the connected
|
|
// chain server.
|
|
func (s *rpcServer) postPassthrough(w http.ResponseWriter, request rawRequest) {
|
|
resp := passthrough(request)
|
|
if _, err := w.Write(resp); err != nil {
|
|
log.Warnf("Unable to respond to client with passthrough "+
|
|
"response: %v", err)
|
|
}
|
|
}
|
|
|
|
// passthrough is a helper function for websocketPassthrough and postPassthrough
|
|
// to request and receive the chain server's marshaled response to an
|
|
// unhandled-by-wallet request. The marshaled response includes the original
|
|
// request's ID.
|
|
func passthrough(request rawRequest) []byte {
|
|
var res json.RawMessage
|
|
rpcc, err := accessClient()
|
|
if err == nil {
|
|
res, err = rpcc.RawRequest(request.Method, request.Params)
|
|
}
|
|
var jsonErr *btcjson.Error
|
|
if err != nil {
|
|
switch e := err.(type) {
|
|
case *btcjson.Error:
|
|
jsonErr = e
|
|
case btcjson.Error:
|
|
jsonErr = &e
|
|
default:
|
|
jsonErr = &btcjson.Error{
|
|
Code: btcjson.ErrWallet.Code,
|
|
Message: err.Error(),
|
|
}
|
|
}
|
|
}
|
|
|
|
// The raw result will only marshal correctly if called with the
|
|
// MarshalJSON method, and that method requires a pointer receiver.
|
|
var pres *json.RawMessage
|
|
if res != nil {
|
|
pres = &res
|
|
}
|
|
|
|
resp := btcjson.Reply{
|
|
Id: idPointer(request.ID),
|
|
Result: pres,
|
|
Error: jsonErr,
|
|
}
|
|
mresp, err := json.Marshal(resp)
|
|
// The chain server response was successfully unmarshaled or we created
|
|
// our own error, so a marshal can never error.
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return mresp
|
|
}
|
|
|
|
type unauthedRequest struct {
|
|
marshaledRequest []byte
|
|
handler requestHandler
|
|
}
|
|
|
|
func (s *rpcServer) WebsocketClientGateway(wsc *websocketClient) {
|
|
out:
|
|
// A for-select with a read of the quit channel is used instead of a
|
|
// for-range to provide clean shutdown. This is necessary due to
|
|
// WebsocketClientRead (which sends to the allRequests chan) not closing
|
|
// allRequests during shutdown if the remote websocket client is still
|
|
// connected.
|
|
for {
|
|
select {
|
|
case request, ok := <-wsc.allRequests:
|
|
if !ok {
|
|
// client disconnected
|
|
break out
|
|
}
|
|
// Get the method of the request and check whether it
|
|
// should be handled by wallet or passed down to btcd.
|
|
// If the latter, handle in a new goroutine (to not
|
|
// block or be blocked by the handling of actual wallet
|
|
// requests).
|
|
//
|
|
// This is done by unmarshaling the JSON bytes into a
|
|
// rawRequest to avoid the mangling of unmarshaling and
|
|
// re-marshaling of large JSON numbers, as well as the
|
|
// overhead of unneeded unmarshals and marshals.
|
|
var raw rawRequest
|
|
if err := json.Unmarshal(request, &raw); err != nil {
|
|
if !wsc.authenticated {
|
|
// Disconnect immediately.
|
|
break out
|
|
}
|
|
err = wsc.send(marshalError(idPointer(raw.ID)))
|
|
if err != nil {
|
|
break out
|
|
}
|
|
continue
|
|
}
|
|
|
|
f, ok := handlerFunc(raw.Method, true)
|
|
if ok || raw.Method == "authenticate" {
|
|
// unauthedRequests is buffered to the max
|
|
// number of concurrent websocket client
|
|
// requests so as to not block the passthrough
|
|
// of later btcd requests.
|
|
wsc.unauthedRequests <- unauthedRequest{request, f}
|
|
} else {
|
|
// websocketPassthrough is run as a goroutine to
|
|
// send an unhandled request to the chain server
|
|
// without blocking the handling of later wallet
|
|
// requests.
|
|
go s.websocketPassthrough(wsc, raw)
|
|
}
|
|
case <-s.quit:
|
|
break out
|
|
}
|
|
}
|
|
close(wsc.unauthedRequests)
|
|
s.wg.Done()
|
|
}
|
|
|
|
// invalidAuth checks whether a websocket request is allowed for the current
|
|
// authentication state. If an unauthenticated client submitted an
|
|
// authenticate request, the authentication is verified and the client's
|
|
// authentication state is modified.
|
|
func (s *rpcServer) invalidAuth(wsc *websocketClient, request btcjson.Cmd) (invalid, checked bool) {
|
|
if authCmd, ok := request.(*btcws.AuthenticateCmd); ok {
|
|
// Duplication authentication is not allowed.
|
|
if wsc.authenticated {
|
|
return true, false
|
|
}
|
|
|
|
// Check credentials.
|
|
login := authCmd.Username + ":" + authCmd.Passphrase
|
|
auth := "Basic " + base64.StdEncoding.EncodeToString([]byte(login))
|
|
authSha := sha256.Sum256([]byte(auth))
|
|
cmp := subtle.ConstantTimeCompare(authSha[:], s.authsha[:])
|
|
wsc.authenticated = cmp == 1
|
|
return cmp != 1, true
|
|
}
|
|
// Unauthorized clients must first issue an authenticate request. If
|
|
// not already authenticated, the auth is invalid.
|
|
return !wsc.authenticated, false
|
|
}
|
|
|
|
func (s *rpcServer) WebsocketClientRespond(wsc *websocketClient) {
|
|
out:
|
|
for r := range wsc.unauthedRequests {
|
|
cmd, parseErr := btcjson.ParseMarshaledCmd(r.marshaledRequest)
|
|
var id interface{}
|
|
if cmd != nil {
|
|
id = cmd.Id()
|
|
}
|
|
|
|
// Verify that the websocket is authenticated and not send an
|
|
// unnecessary authentication request, or perform the check
|
|
// if unauthenticated and this is an authentication request.
|
|
// Disconnect the client immediately if the authentication is
|
|
// invalid or disallowed.
|
|
switch invalid, checked := s.invalidAuth(wsc, cmd); {
|
|
case invalid:
|
|
log.Warnf("Disconnecting improperly authenticated "+
|
|
"websocket client %s", wsc.remoteAddr)
|
|
break out
|
|
case checked:
|
|
// Marshal and send a successful auth response. The
|
|
// marshal is expected to never fail.
|
|
response := btcjson.Reply{Id: idPointer(id)}
|
|
mresponse, err := json.Marshal(response)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
if err := wsc.send(mresponse); err != nil {
|
|
break out
|
|
}
|
|
continue
|
|
}
|
|
|
|
// The parse error is checked after the authentication check
|
|
// so we don't respond back for invalid requests sent by
|
|
// unauthenticated clients.
|
|
if parseErr != nil {
|
|
if wsc.send(marshalError(idPointer(id))) != nil {
|
|
break out
|
|
}
|
|
continue
|
|
}
|
|
|
|
// Send request and the handler func (already looked up) to the
|
|
// server's global request handler. This serializes the
|
|
// execution of all handlers from all connections (both
|
|
// websocket and HTTP POST), and runs the handler with exclusive
|
|
// access of the account manager.
|
|
var response handlerResponse
|
|
responseChan := make(chan handlerResponse)
|
|
job := handlerJob{
|
|
request: cmd,
|
|
handler: r.handler,
|
|
response: responseChan,
|
|
}
|
|
select {
|
|
case s.requests <- job:
|
|
select {
|
|
case response = <-responseChan:
|
|
case <-s.quit:
|
|
break out
|
|
}
|
|
case <-s.quit:
|
|
break out
|
|
}
|
|
resp := btcjson.Reply{
|
|
Id: idPointer(id),
|
|
Result: response.result,
|
|
Error: response.jsonErr,
|
|
}
|
|
mresp, err := json.Marshal(resp)
|
|
// All responses originating from us must be marshalable.
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
// Send marshaled response to client.
|
|
if err := wsc.send(mresp); err != nil {
|
|
break out
|
|
}
|
|
}
|
|
|
|
// Remove websocket client from notification group, or if the server is
|
|
// shutting down, wait until the notification handler has finished
|
|
// running. This is needed to ensure that no more notifications will be
|
|
// sent to the client's responses chan before it's closed below.
|
|
select {
|
|
case s.removeWSClient <- wsc:
|
|
case <-s.quit:
|
|
<-s.notificationHandlerQuit
|
|
}
|
|
|
|
close(wsc.responses)
|
|
s.wg.Done()
|
|
}
|
|
|
|
func (s *rpcServer) WebsocketClientSend(wsc *websocketClient) {
|
|
const deadline time.Duration = 2 * time.Second
|
|
for response := range wsc.responses {
|
|
err := wsc.conn.SetWriteDeadline(time.Now().Add(deadline))
|
|
if err != nil {
|
|
log.Warnf("Cannot set write deadline on client %s: %v",
|
|
wsc.remoteAddr, err)
|
|
}
|
|
err = wsc.conn.WriteMessage(websocket.TextMessage, response)
|
|
if err != nil {
|
|
log.Warnf("Failed websocket send to client %s: %v",
|
|
wsc.remoteAddr, err)
|
|
break
|
|
}
|
|
}
|
|
close(wsc.quit)
|
|
log.Infof("Disconnected websocket client %s", wsc.remoteAddr)
|
|
select {
|
|
case s.removeWSClient <- wsc:
|
|
case <-s.quit:
|
|
}
|
|
s.wg.Done()
|
|
}
|
|
|
|
// WebsocketClientRPC starts the goroutines to serve JSON-RPC requests and
|
|
// notifications over a websocket connection for a single client.
|
|
func (s *rpcServer) WebsocketClientRPC(wsc *websocketClient) {
|
|
log.Infof("New websocket client %s", wsc.remoteAddr)
|
|
|
|
// Clear the read deadline set before the websocket hijacked
|
|
// the connection.
|
|
if err := wsc.conn.SetReadDeadline(time.Time{}); err != nil {
|
|
log.Warnf("Cannot remove read deadline: %v", err)
|
|
}
|
|
|
|
// Add client context so notifications duplicated to each
|
|
// client are received by this client.
|
|
select {
|
|
case s.addWSClient <- wsc:
|
|
case <-s.quit:
|
|
return
|
|
}
|
|
|
|
// WebsocketClientRead is intentionally not run with the waitgroup
|
|
// so it is ignored during shutdown. This is to prevent a hang during
|
|
// shutdown where the goroutine is blocked on a read of the
|
|
// websocket connection if the client is still connected.
|
|
go s.WebsocketClientRead(wsc)
|
|
|
|
s.wg.Add(3)
|
|
go s.WebsocketClientGateway(wsc)
|
|
go s.WebsocketClientRespond(wsc)
|
|
go s.WebsocketClientSend(wsc)
|
|
|
|
// Send initial unsolicited notifications.
|
|
// TODO: these should be requested by the client first.
|
|
s.NotifyConnectionStatus(wsc)
|
|
|
|
<-wsc.quit
|
|
}
|
|
|
|
// maxRequestSize specifies the maximum number of bytes in the request body
|
|
// that may be read from a client. This is currently limited to 4MB.
|
|
const maxRequestSize = 1024 * 1024 * 4
|
|
|
|
// PostClientRPC processes and replies to a JSON-RPC client request.
|
|
func (s *rpcServer) PostClientRPC(w http.ResponseWriter, r *http.Request) {
|
|
body := http.MaxBytesReader(w, r.Body, maxRequestSize)
|
|
rpcRequest, err := ioutil.ReadAll(body)
|
|
if err != nil {
|
|
// TODO: what if the underlying reader errored?
|
|
http.Error(w, "413 Request Too Large.",
|
|
http.StatusRequestEntityTooLarge)
|
|
return
|
|
}
|
|
|
|
// First check whether wallet has a handler for this request's method.
|
|
// If unfound, the request is sent to the chain server for further
|
|
// processing. While checking the methods, disallow authenticate
|
|
// requests, as they are invalid for HTTP POST clients.
|
|
var raw rawRequest
|
|
err = json.Unmarshal(rpcRequest, &raw)
|
|
if err != nil || raw.Method == "authenticate" {
|
|
_, err := w.Write(marshalError(idPointer(raw.ID)))
|
|
if err != nil {
|
|
log.Warnf("Cannot write invalid request request to "+
|
|
"client: %v", err)
|
|
}
|
|
return
|
|
}
|
|
f, ok := handlerFunc(raw.Method, false)
|
|
if !ok {
|
|
s.postPassthrough(w, raw)
|
|
return
|
|
}
|
|
|
|
// Parse the full request since it must be handled by wallet.
|
|
cmd, err := btcjson.ParseMarshaledCmd(rpcRequest)
|
|
var idPtr *interface{}
|
|
if cmd != nil {
|
|
idPtr = idPointer(cmd.Id())
|
|
}
|
|
if err != nil {
|
|
_, err := w.Write(marshalError(idPtr))
|
|
if err != nil {
|
|
log.Warnf("Client sent invalid request but unable "+
|
|
"to respond with error: %v", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
// Send request and the handler func (already looked up) to the
|
|
// server's global request handler. This serializes the
|
|
// execution of all handlers from all connections (both
|
|
// websocket and HTTP POST), and runs the handler with exclusive
|
|
// access of the account manager.
|
|
var response handlerResponse
|
|
responseChan := make(chan handlerResponse)
|
|
job := handlerJob{
|
|
request: cmd,
|
|
handler: f,
|
|
response: responseChan,
|
|
}
|
|
select {
|
|
case s.requests <- job:
|
|
select {
|
|
case response = <-responseChan:
|
|
case <-s.quit:
|
|
return
|
|
}
|
|
case <-s.quit:
|
|
return
|
|
}
|
|
resp := btcjson.Reply{
|
|
Id: idPtr,
|
|
Result: response.result,
|
|
Error: response.jsonErr,
|
|
}
|
|
mresp, err := json.Marshal(resp)
|
|
// All responses originating from us must be marshalable.
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
// Send marshaled response to client.
|
|
if _, err := w.Write(mresp); err != nil {
|
|
log.Warnf("Unable to respond to client: %v", err)
|
|
}
|
|
}
|
|
|
|
// NotifyConnectionStatus notifies all connected websocket clients of the
|
|
// current connection status of btcwallet to btcd.
|
|
func (s *rpcServer) NotifyConnectionStatus(wsc *websocketClient) {
|
|
connected := false
|
|
rpcc, err := accessClient()
|
|
if err == nil {
|
|
connected = !rpcc.Disconnected()
|
|
}
|
|
ntfn := btcws.NewBtcdConnectedNtfn(connected)
|
|
mntfn, err := ntfn.MarshalJSON()
|
|
// btcws notifications must always marshal without error.
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
if wsc == nil {
|
|
select {
|
|
case s.broadcasts <- mntfn:
|
|
case <-s.quit:
|
|
}
|
|
} else {
|
|
// Don't care whether the client disconnected at this
|
|
// point, so discard error.
|
|
_ = wsc.send(mntfn)
|
|
}
|
|
}
|
|
|
|
func (s *rpcServer) NotificationHandler() {
|
|
out:
|
|
for {
|
|
select {
|
|
case c := <-s.addWSClient:
|
|
s.wsClients[c] = struct{}{}
|
|
case c := <-s.removeWSClient:
|
|
delete(s.wsClients, c)
|
|
case b := <-s.broadcasts:
|
|
for wsc := range s.wsClients {
|
|
if err := wsc.send(b); err != nil {
|
|
delete(s.wsClients, wsc)
|
|
}
|
|
}
|
|
case <-s.quit:
|
|
break out
|
|
}
|
|
}
|
|
close(s.notificationHandlerQuit)
|
|
s.wg.Done()
|
|
}
|
|
|
|
// requestHandler is a handler function to handle an unmarshaled and parsed
|
|
// request into a marshalable response. If the error is a btcjson.Error
|
|
// or any of the above special error classes, the server will respond with
|
|
// the JSON-RPC appropiate error code. All other errors use the wallet
|
|
// catch-all error code, btcjson.ErrWallet.Code.
|
|
type requestHandler func(btcjson.Cmd) (interface{}, error)
|
|
|
|
var rpcHandlers = map[string]requestHandler{
|
|
// Standard bitcoind methods (implemented)
|
|
"addmultisigaddress": AddMultiSigAddress,
|
|
"createmultisig": CreateMultiSig,
|
|
"dumpprivkey": DumpPrivKey,
|
|
"getaccount": GetAccount,
|
|
"getaccountaddress": GetAccountAddress,
|
|
"getaddressesbyaccount": GetAddressesByAccount,
|
|
"getbalance": GetBalance,
|
|
"getinfo": GetInfo,
|
|
"getnewaddress": GetNewAddress,
|
|
"getrawchangeaddress": GetRawChangeAddress,
|
|
"getreceivedbyaccount": GetReceivedByAccount,
|
|
"gettransaction": GetTransaction,
|
|
"importprivkey": ImportPrivKey,
|
|
"keypoolrefill": KeypoolRefill,
|
|
"listaccounts": ListAccounts,
|
|
"listlockunspent": ListLockUnspent,
|
|
"listreceivedbyaddress": ListReceivedByAddress,
|
|
"listsinceblock": ListSinceBlock,
|
|
"listtransactions": ListTransactions,
|
|
"listunspent": ListUnspent,
|
|
"lockunspent": LockUnspent,
|
|
"sendfrom": SendFrom,
|
|
"sendmany": SendMany,
|
|
"sendtoaddress": SendToAddress,
|
|
"settxfee": SetTxFee,
|
|
"signmessage": SignMessage,
|
|
"signrawtransaction": SignRawTransaction,
|
|
"stop": Stop,
|
|
"validateaddress": ValidateAddress,
|
|
"verifymessage": VerifyMessage,
|
|
"walletlock": WalletLock,
|
|
"walletpassphrase": WalletPassphrase,
|
|
"walletpassphrasechange": WalletPassphraseChange,
|
|
|
|
// Standard bitcoind methods (currently unimplemented)
|
|
"backupwallet": Unimplemented,
|
|
"dumpwallet": Unimplemented,
|
|
"getreceivedbyaddress": Unimplemented,
|
|
"getwalletinfo": Unimplemented,
|
|
"importwallet": Unimplemented,
|
|
"listaddressgroupings": Unimplemented,
|
|
"listreceivedbyaccount": Unimplemented,
|
|
"move": Unimplemented,
|
|
"setaccount": Unimplemented,
|
|
|
|
// Standard bitcoind methods which won't be implemented by btcwallet.
|
|
"encryptwallet": Unsupported,
|
|
|
|
// Extensions not exclusive to websocket connections.
|
|
"createencryptedwallet": CreateEncryptedWallet,
|
|
}
|
|
|
|
// Extensions exclusive to websocket connections.
|
|
var wsHandlers = map[string]requestHandler{
|
|
"exportwatchingwallet": ExportWatchingWallet,
|
|
"getaddressbalance": GetAddressBalance,
|
|
"getunconfirmedbalance": GetUnconfirmedBalance,
|
|
"listaddresstransactions": ListAddressTransactions,
|
|
"listalltransactions": ListAllTransactions,
|
|
"recoveraddresses": RecoverAddresses,
|
|
"walletislocked": WalletIsLocked,
|
|
}
|
|
|
|
// handlerFunc looks up a request handler func for the passed method from
|
|
// the http post and (if the request is from a websocket connection) websocket
|
|
// handler maps. If a suitable handler could not be found, ok is false.
|
|
func handlerFunc(method string, ws bool) (f requestHandler, ok bool) {
|
|
f, ok = rpcHandlers[method]
|
|
if !ok && ws {
|
|
f, ok = wsHandlers[method]
|
|
}
|
|
return f, ok
|
|
}
|
|
|
|
type handlerResponse struct {
|
|
result interface{}
|
|
jsonErr *btcjson.Error
|
|
}
|
|
|
|
type handlerJob struct {
|
|
request btcjson.Cmd
|
|
handler requestHandler
|
|
response chan<- handlerResponse
|
|
}
|
|
|
|
// RequestHandler reads and processes client requests from the request channel.
|
|
// Each request is run with exclusive access to the account manager.
|
|
func (s *rpcServer) RequestHandler() {
|
|
out:
|
|
for {
|
|
select {
|
|
case r := <-s.requests:
|
|
AcctMgr.Grab()
|
|
result, err := r.handler(r.request)
|
|
AcctMgr.Release()
|
|
|
|
var jsonErr *btcjson.Error
|
|
if err != nil {
|
|
jsonErr = &btcjson.Error{Message: err.Error()}
|
|
switch e := err.(type) {
|
|
case btcjson.Error:
|
|
*jsonErr = e
|
|
case *btcjson.Error:
|
|
*jsonErr = *e
|
|
case DeserializationError:
|
|
jsonErr.Code = btcjson.ErrDeserialization.Code
|
|
case InvalidParameterError:
|
|
jsonErr.Code = btcjson.ErrInvalidParameter.Code
|
|
case ParseError:
|
|
jsonErr.Code = btcjson.ErrParse.Code
|
|
case InvalidAddressOrKeyError:
|
|
jsonErr.Code = btcjson.ErrInvalidAddressOrKey.Code
|
|
default: // All other errors get the wallet error code.
|
|
jsonErr.Code = btcjson.ErrWallet.Code
|
|
}
|
|
}
|
|
// The goroutine which requested this may not be running
|
|
// anymore. If the quit chan is read instead, break out
|
|
// of the loop now so more requests aren't potentially
|
|
// read after reentering the loop.
|
|
select {
|
|
case r.response <- handlerResponse{result, jsonErr}:
|
|
case <-s.quit:
|
|
break out
|
|
}
|
|
|
|
case <-s.quit:
|
|
break out
|
|
}
|
|
}
|
|
s.wg.Done()
|
|
}
|
|
|
|
// Unimplemented handles an unimplemented RPC request with the
|
|
// appropiate error.
|
|
func Unimplemented(btcjson.Cmd) (interface{}, error) {
|
|
return nil, btcjson.ErrUnimplemented
|
|
}
|
|
|
|
// Unsupported handles a standard bitcoind RPC request which is
|
|
// unsupported by btcwallet due to design differences.
|
|
func Unsupported(btcjson.Cmd) (interface{}, error) {
|
|
return nil, btcjson.Error{
|
|
Code: -1,
|
|
Message: "Request unsupported by btcwallet",
|
|
}
|
|
}
|
|
|
|
// makeMultiSigScript is a helper function to combine common logic for
|
|
// AddMultiSig and CreateMultiSig.
|
|
// all error codes are rpc parse error here to match bitcoind which just throws
|
|
// a runtime exception. *sigh*.
|
|
func makeMultiSigScript(keys []string, nRequired int) ([]byte, error) {
|
|
keysesPrecious := make([]*btcutil.AddressPubKey, len(keys))
|
|
|
|
// The address list will made up either of addreseses (pubkey hash), for
|
|
// which we need to look up the keys in wallet, straight pubkeys, or a
|
|
// mixture of the two.
|
|
for i, a := range keys {
|
|
// try to parse as pubkey address
|
|
a, err := btcutil.DecodeAddress(a, activeNet.Params)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
switch addr := a.(type) {
|
|
case *btcutil.AddressPubKey:
|
|
keysesPrecious[i] = addr
|
|
case *btcutil.AddressPubKeyHash:
|
|
ainfo, err := AcctMgr.Address(addr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
apkinfo := ainfo.(keystore.PubKeyAddress)
|
|
|
|
// This will be an addresspubkey
|
|
a, err := btcutil.DecodeAddress(apkinfo.ExportPubKey(),
|
|
activeNet.Params)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
apk := a.(*btcutil.AddressPubKey)
|
|
keysesPrecious[i] = apk
|
|
default:
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
return btcscript.MultiSigScript(keysesPrecious, nRequired)
|
|
}
|
|
|
|
// AddMultiSigAddress handles an addmultisigaddress request by adding a
|
|
// multisig address to the given wallet.
|
|
func AddMultiSigAddress(icmd btcjson.Cmd) (interface{}, error) {
|
|
cmd, ok := icmd.(*btcjson.AddMultisigAddressCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
acct, err := AcctMgr.Account(cmd.Account)
|
|
if err != nil {
|
|
if err == ErrNotFound {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
script, err := makeMultiSigScript(cmd.Keys, cmd.NRequired)
|
|
if err != nil {
|
|
return nil, ParseError{err}
|
|
}
|
|
|
|
// TODO(oga) blockstamp current block?
|
|
address, err := acct.KeyStore.ImportScript(script,
|
|
&keystore.BlockStamp{})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Write wallet with imported multisig address to disk.
|
|
AcctMgr.ds.ScheduleWalletWrite(acct)
|
|
if err := AcctMgr.ds.FlushAccount(acct); err != nil {
|
|
return nil, fmt.Errorf("account write failed: %v", err)
|
|
}
|
|
|
|
// Associate the import address with this account.
|
|
AcctMgr.MarkAddressForAccount(address, acct)
|
|
|
|
return address.EncodeAddress(), nil
|
|
}
|
|
|
|
// CreateMultiSig handles an createmultisig request by returning a
|
|
// multisig address for the given inputs.
|
|
func CreateMultiSig(icmd btcjson.Cmd) (interface{}, error) {
|
|
cmd, ok := icmd.(*btcjson.CreateMultisigCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
script, err := makeMultiSigScript(cmd.Keys, cmd.NRequired)
|
|
if err != nil {
|
|
return nil, ParseError{err}
|
|
}
|
|
|
|
address, err := btcutil.NewAddressScriptHash(script, activeNet.Params)
|
|
if err != nil {
|
|
// above is a valid script, shouldn't happen.
|
|
return nil, err
|
|
}
|
|
|
|
return btcjson.CreateMultiSigResult{
|
|
Address: address.EncodeAddress(),
|
|
RedeemScript: hex.EncodeToString(script),
|
|
}, nil
|
|
}
|
|
|
|
// DumpPrivKey handles a dumpprivkey request with the private key
|
|
// for a single address, or an appropiate error if the wallet
|
|
// is locked.
|
|
func DumpPrivKey(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.DumpPrivKeyCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
addr, err := btcutil.DecodeAddress(cmd.Address, activeNet.Params)
|
|
if err != nil {
|
|
return nil, btcjson.ErrInvalidAddressOrKey
|
|
}
|
|
|
|
key, err := AcctMgr.DumpWIFPrivateKey(addr)
|
|
if err == keystore.ErrLocked {
|
|
// Address was found, but the private key isn't
|
|
// accessible.
|
|
return nil, btcjson.ErrWalletUnlockNeeded
|
|
}
|
|
return key, err
|
|
}
|
|
|
|
// DumpWallet handles a dumpwallet request by returning all private
|
|
// keys in a wallet, or an appropiate error if the wallet is locked.
|
|
// TODO: finish this to match bitcoind by writing the dump to a file.
|
|
func DumpWallet(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
_, ok := icmd.(*btcjson.DumpWalletCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
keys, err := AcctMgr.DumpKeys()
|
|
if err == keystore.ErrLocked {
|
|
// Address was found, but the private key isn't
|
|
// accessible.
|
|
return nil, btcjson.ErrWalletUnlockNeeded
|
|
}
|
|
return keys, err
|
|
}
|
|
|
|
// ExportWatchingWallet handles an exportwatchingwallet request by exporting
|
|
// the current account wallet as a watching wallet (with no private keys), and
|
|
// either writing the exported wallet to disk, or base64-encoding serialized
|
|
// account files and sending them back in the response.
|
|
func ExportWatchingWallet(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcws.ExportWatchingWalletCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
a, err := AcctMgr.Account(cmd.Account)
|
|
if err != nil {
|
|
if err == ErrNotFound {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
wa, err := a.ExportWatchingWallet()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if cmd.Download {
|
|
return wa.exportBase64()
|
|
}
|
|
|
|
// Create export directory, write files there.
|
|
err = wa.ExportToDirectory("watchingwallet")
|
|
return nil, err
|
|
}
|
|
|
|
// GetAddressesByAccount handles a getaddressesbyaccount request by returning
|
|
// all addresses for an account, or an error if the requested account does
|
|
// not exist.
|
|
func GetAddressesByAccount(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.GetAddressesByAccountCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
a, err := AcctMgr.Account(cmd.Account)
|
|
if err != nil {
|
|
if err == ErrNotFound {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
return nil, err
|
|
}
|
|
return a.SortedActivePaymentAddresses(), nil
|
|
}
|
|
|
|
// GetBalance handles a getbalance request by returning the balance for an
|
|
// account (wallet), or an error if the requested account does not
|
|
// exist.
|
|
func GetBalance(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.GetBalanceCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
balance, err := AcctMgr.CalculateBalance(cmd.Account, cmd.MinConf)
|
|
if err == ErrNotFound {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
return balance.ToUnit(btcutil.AmountBTC), err
|
|
}
|
|
|
|
// GetInfo handles a getinfo request by returning the a structure containing
|
|
// information about the current state of btcwallet.
|
|
// exist.
|
|
func GetInfo(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Call down to btcd for all of the information in this command known
|
|
// by them.
|
|
rpcc, err := accessClient()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
info, err := rpcc.GetInfo()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var balance, feeIncr btcutil.Amount
|
|
accounts := AcctMgr.AllAccounts()
|
|
for _, a := range accounts {
|
|
bal, err := a.CalculateBalance(1)
|
|
if err == nil {
|
|
balance += bal
|
|
}
|
|
// For now we assume all transactions can only be created
|
|
// with the default account (as this is the only account
|
|
// that's usable), so use it for the fee increment.
|
|
if a.name == "" {
|
|
feeIncr = a.FeeIncrement
|
|
}
|
|
}
|
|
info.WalletVersion = int32(keystore.VersCurrent.Uint32())
|
|
info.Balance = balance.ToUnit(btcutil.AmountBTC)
|
|
// Keypool times are not tracked. set to current time.
|
|
info.KeypoolOldest = time.Now().Unix()
|
|
info.KeypoolSize = int32(cfg.KeypoolSize)
|
|
info.PaytxFee = feeIncr.ToUnit(btcutil.AmountBTC)
|
|
// We don't set the following since they don't make much sense in the
|
|
// wallet architecture:
|
|
// - unlocked_until
|
|
// - errors
|
|
|
|
return info, nil
|
|
}
|
|
|
|
// GetAccount handles a getaccount request by returning the account name
|
|
// associated with a single address.
|
|
func GetAccount(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.GetAccountCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
// Is address valid?
|
|
addr, err := btcutil.DecodeAddress(cmd.Address, activeNet.Params)
|
|
if err != nil || !addr.IsForNet(activeNet.Params) {
|
|
return nil, btcjson.ErrInvalidAddressOrKey
|
|
}
|
|
|
|
// Look up account which holds this address.
|
|
acct, err := AcctMgr.AccountByAddress(addr)
|
|
if err != nil {
|
|
if err == ErrNotFound {
|
|
return nil, ErrAddressNotInWallet
|
|
}
|
|
return nil, err
|
|
}
|
|
return acct.KeyStore.Name(), nil
|
|
}
|
|
|
|
// GetAccountAddress handles a getaccountaddress by returning the most
|
|
// recently-created chained address that has not yet been used (does not yet
|
|
// appear in the blockchain, or any tx that has arrived in the btcd mempool).
|
|
// If the most recently-requested address has been used, a new address (the
|
|
// next chained address in the keypool) is used. This can fail if the keypool
|
|
// runs out (and will return btcjson.ErrWalletKeypoolRanOut if that happens).
|
|
func GetAccountAddress(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.GetAccountAddressCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
// Lookup account for this request.
|
|
a, err := AcctMgr.Account(cmd.Account)
|
|
if err != nil {
|
|
if err == ErrNotFound {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
addr, err := a.CurrentAddress()
|
|
if err != nil {
|
|
if err == keystore.ErrLocked {
|
|
return nil, btcjson.ErrWalletKeypoolRanOut
|
|
}
|
|
return nil, err
|
|
}
|
|
return addr.EncodeAddress(), err
|
|
}
|
|
|
|
// GetAddressBalance handles a getaddressbalance extension request by
|
|
// returning the current balance (sum of unspent transaction output amounts)
|
|
// for a single address.
|
|
func GetAddressBalance(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcws.GetAddressBalanceCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
// Is address valid?
|
|
addr, err := btcutil.DecodeAddress(cmd.Address, activeNet.Params)
|
|
if err != nil {
|
|
return nil, btcjson.ErrInvalidAddressOrKey
|
|
}
|
|
|
|
// Get the account which holds the address in the request.
|
|
a, err := AcctMgr.AccountByAddress(addr)
|
|
if err != nil {
|
|
return nil, ErrAddressNotInWallet
|
|
}
|
|
|
|
bal, err := a.CalculateAddressBalance(addr, int(cmd.Minconf))
|
|
return bal.ToUnit(btcutil.AmountBTC), err
|
|
}
|
|
|
|
// GetUnconfirmedBalance handles a getunconfirmedbalance extension request
|
|
// by returning the current unconfirmed balance of an account.
|
|
func GetUnconfirmedBalance(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcws.GetUnconfirmedBalanceCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
// Get the account included in the request.
|
|
a, err := AcctMgr.Account(cmd.Account)
|
|
if err != nil {
|
|
if err == ErrNotFound {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
unconfirmed, err := a.CalculateBalance(0)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
confirmed, err := a.CalculateBalance(1)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return (unconfirmed - confirmed).ToUnit(btcutil.AmountBTC), nil
|
|
}
|
|
|
|
// ImportPrivKey handles an importprivkey request by parsing
|
|
// a WIF-encoded private key and adding it to an account.
|
|
func ImportPrivKey(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.ImportPrivKeyCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
// Get the acount included in the request. Yes, Label is the
|
|
// account name...
|
|
a, err := AcctMgr.Account(cmd.Label)
|
|
if err != nil {
|
|
if err == ErrNotFound {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
wif, err := btcutil.DecodeWIF(cmd.PrivKey)
|
|
if err != nil || !wif.IsForNet(activeNet.Params) {
|
|
return nil, btcjson.ErrInvalidAddressOrKey
|
|
}
|
|
|
|
// Import the private key, handling any errors.
|
|
bs := keystore.BlockStamp{}
|
|
if _, err := a.ImportPrivateKey(wif, &bs, cmd.Rescan); err != nil {
|
|
switch err {
|
|
case keystore.ErrDuplicate:
|
|
// Do not return duplicate key errors to the client.
|
|
return nil, nil
|
|
case keystore.ErrLocked:
|
|
return nil, btcjson.ErrWalletUnlockNeeded
|
|
default:
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// If the import was successful, reply with nil.
|
|
return nil, nil
|
|
}
|
|
|
|
// KeypoolRefill handles the keypoolrefill command. Since we handle the keypool
|
|
// automatically this does nothing since refilling is never manually required.
|
|
func KeypoolRefill(icmd btcjson.Cmd) (interface{}, error) {
|
|
return nil, nil
|
|
}
|
|
|
|
// NotifyNewBlockChainHeight notifies all websocket clients of a new
|
|
// blockchain height. This sends the same notification as
|
|
// btcd, so this can probably be removed.
|
|
func (s *rpcServer) NotifyNewBlockChainHeight(bs *keystore.BlockStamp) {
|
|
ntfn := btcws.NewBlockConnectedNtfn(bs.Hash.String(), bs.Height)
|
|
mntfn, err := ntfn.MarshalJSON()
|
|
// btcws notifications must always marshal without error.
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
select {
|
|
case s.broadcasts <- mntfn:
|
|
case <-s.quit:
|
|
}
|
|
}
|
|
|
|
// NotifyBalances notifies an attached websocket clients of the current
|
|
// confirmed and unconfirmed account balances.
|
|
//
|
|
// TODO(jrick): Switch this to return a single JSON object
|
|
// (map[string]interface{}) of all accounts and their balances, instead of
|
|
// separate notifications for each account.
|
|
func (s *rpcServer) NotifyBalances() {
|
|
for _, a := range AcctMgr.AllAccounts() {
|
|
balance, err := a.CalculateBalance(1)
|
|
var unconfirmed btcutil.Amount
|
|
if err == nil {
|
|
unconfirmed, err = a.CalculateBalance(0)
|
|
}
|
|
if err != nil {
|
|
break
|
|
}
|
|
unconfirmed -= balance
|
|
s.NotifyWalletBalance(a.name, balance)
|
|
s.NotifyWalletBalanceUnconfirmed(a.name, unconfirmed)
|
|
}
|
|
}
|
|
|
|
// GetNewAddress handlesa getnewaddress request by returning a new
|
|
// address for an account. If the account does not exist or the keypool
|
|
// ran out with a locked wallet, an appropiate error is returned.
|
|
func GetNewAddress(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.GetNewAddressCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
a, err := AcctMgr.Account(cmd.Account)
|
|
if err != nil {
|
|
if err == ErrNotFound {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
addr, err := a.NewAddress()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Return the new payment address string.
|
|
return addr.EncodeAddress(), nil
|
|
}
|
|
|
|
// GetRawChangeAddress handles a getrawchangeaddress request by creating
|
|
// and returning a new change address for an account.
|
|
//
|
|
// Note: bitcoind allows specifying the account as an optional parameter,
|
|
// but ignores the parameter.
|
|
func GetRawChangeAddress(icmd btcjson.Cmd) (interface{}, error) {
|
|
cmd, ok := icmd.(*btcjson.GetRawChangeAddressCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
a, err := AcctMgr.Account(cmd.Account)
|
|
if err != nil {
|
|
if err == ErrNotFound {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
addr, err := a.NewChangeAddress()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Return the new payment address string.
|
|
return addr.EncodeAddress(), nil
|
|
}
|
|
|
|
// GetReceivedByAccount handles a getreceivedbyaccount request by returning
|
|
// the total amount received by addresses of an account.
|
|
func GetReceivedByAccount(icmd btcjson.Cmd) (interface{}, error) {
|
|
cmd, ok := icmd.(*btcjson.GetReceivedByAccountCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
a, err := AcctMgr.Account(cmd.Account)
|
|
if err != nil {
|
|
if err == ErrNotFound {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
bal, err := a.TotalReceived(cmd.MinConf)
|
|
return bal.ToUnit(btcutil.AmountBTC), err
|
|
}
|
|
|
|
// GetTransaction handles a gettransaction request by returning details about
|
|
// a single transaction saved by wallet.
|
|
func GetTransaction(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.GetTransactionCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
txSha, err := btcwire.NewShaHashFromStr(cmd.Txid)
|
|
if err != nil {
|
|
return nil, btcjson.ErrDecodeHexString
|
|
}
|
|
|
|
accumulatedTxen := AcctMgr.GetTransaction(txSha)
|
|
if len(accumulatedTxen) == 0 {
|
|
return nil, btcjson.ErrNoTxInfo
|
|
}
|
|
|
|
rpcc, err := accessClient()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
bs, err := rpcc.BlockStamp()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
received := btcutil.Amount(0)
|
|
var debits *txstore.Debits
|
|
var debitAccount string
|
|
var targetAddr string
|
|
|
|
ret := btcjson.GetTransactionResult{
|
|
Details: []btcjson.GetTransactionDetailsResult{},
|
|
WalletConflicts: []string{},
|
|
}
|
|
details := []btcjson.GetTransactionDetailsResult{}
|
|
for _, e := range accumulatedTxen {
|
|
for _, cred := range e.Tx.Credits() {
|
|
// Change is ignored.
|
|
if cred.Change() {
|
|
continue
|
|
}
|
|
|
|
received += cred.Amount()
|
|
|
|
var addr string
|
|
// Errors don't matter here, as we only consider the
|
|
// case where len(addrs) == 1.
|
|
_, addrs, _, _ := cred.Addresses(activeNet.Params)
|
|
if len(addrs) == 1 {
|
|
addr = addrs[0].EncodeAddress()
|
|
// The first non-change output address is considered the
|
|
// target for sent transactions.
|
|
if targetAddr == "" {
|
|
targetAddr = addr
|
|
}
|
|
}
|
|
|
|
details = append(details, btcjson.GetTransactionDetailsResult{
|
|
Account: e.Account,
|
|
Category: cred.Category(bs.Height).String(),
|
|
Amount: cred.Amount().ToUnit(btcutil.AmountBTC),
|
|
Address: addr,
|
|
})
|
|
}
|
|
|
|
if d, err := e.Tx.Debits(); err == nil {
|
|
// There should only be a single debits record for any
|
|
// of the account's transaction records.
|
|
debits = &d
|
|
debitAccount = e.Account
|
|
}
|
|
}
|
|
|
|
totalAmount := received
|
|
if debits != nil {
|
|
totalAmount -= debits.InputAmount()
|
|
info := btcjson.GetTransactionDetailsResult{
|
|
Account: debitAccount,
|
|
Address: targetAddr,
|
|
Category: "send",
|
|
// negative since it is a send
|
|
Amount: (-debits.OutputAmount(true)).ToUnit(btcutil.AmountBTC),
|
|
Fee: debits.Fee().ToUnit(btcutil.AmountBTC),
|
|
}
|
|
ret.Fee += info.Fee
|
|
// Add sent information to front.
|
|
ret.Details = append(ret.Details, info)
|
|
|
|
}
|
|
ret.Details = append(ret.Details, details...)
|
|
|
|
ret.Amount = totalAmount.ToUnit(btcutil.AmountBTC)
|
|
|
|
// Generic information should be the same, so just use the first one.
|
|
first := accumulatedTxen[0]
|
|
ret.TxID = first.Tx.Tx().Sha().String()
|
|
|
|
buf := bytes.NewBuffer(nil)
|
|
buf.Grow(first.Tx.Tx().MsgTx().SerializeSize())
|
|
err = first.Tx.Tx().MsgTx().Serialize(buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
ret.Hex = hex.EncodeToString(buf.Bytes())
|
|
|
|
// TODO(oga) technically we have different time and
|
|
// timereceived depending on if a transaction was send or
|
|
// receive. We ideally should provide the correct numbers for
|
|
// both. Right now they will always be the same
|
|
ret.Time = first.Tx.Received().Unix()
|
|
ret.TimeReceived = first.Tx.Received().Unix()
|
|
if txr := first.Tx; txr.BlockHeight != -1 {
|
|
txBlock, err := txr.Block()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
ret.BlockIndex = int64(first.Tx.Tx().Index())
|
|
ret.BlockHash = txBlock.Hash.String()
|
|
ret.BlockTime = txBlock.Time.Unix()
|
|
ret.Confirmations = int64(txr.Confirmations(bs.Height))
|
|
}
|
|
// TODO(oga) if the tx is a coinbase we should set "generated" to true.
|
|
// Since we do not mine this currently is never the case.
|
|
return ret, nil
|
|
}
|
|
|
|
// ListAccounts handles a listaccounts request by returning a map of account
|
|
// names to their balances.
|
|
func ListAccounts(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.ListAccountsCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
// Return the map. This will be marshaled into a JSON object.
|
|
return AcctMgr.ListAccounts(cmd.MinConf)
|
|
}
|
|
|
|
// ListLockUnspent handles a listlockunspent request by returning an slice of
|
|
// all locked outpoints.
|
|
func ListLockUnspent(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Due to our poor account support, this assumes only the default
|
|
// account is available. When the keystore and account heirarchies are
|
|
// reversed, the locked outpoints mapping will cover all accounts.
|
|
a, err := AcctMgr.Account("")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return a.LockedOutpoints(), nil
|
|
}
|
|
|
|
// ListReceivedByAddress handles a listreceivedbyaddress request by returning
|
|
// a slice of objects, each one containing:
|
|
// "account": the account of the receiving address;
|
|
// "address": the receiving address;
|
|
// "amount": total amount received by the address;
|
|
// "confirmations": number of confirmations of the most recent transaction.
|
|
// It takes two parameters:
|
|
// "minconf": minimum number of confirmations to consider a transaction -
|
|
// default: one;
|
|
// "includeempty": whether or not to include addresses that have no transactions -
|
|
// default: false.
|
|
func ListReceivedByAddress(icmd btcjson.Cmd) (interface{}, error) {
|
|
cmd, ok := icmd.(*btcjson.ListReceivedByAddressCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
// Intermediate data for each address.
|
|
type AddrData struct {
|
|
// Associated account.
|
|
account *Account
|
|
// Total amount received.
|
|
amount btcutil.Amount
|
|
// Number of confirmations of the last transaction.
|
|
confirmations int32
|
|
}
|
|
|
|
rpcc, err := accessClient()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
bs, err := rpcc.BlockStamp()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Intermediate data for all addresses.
|
|
allAddrData := make(map[string]AddrData)
|
|
for _, account := range AcctMgr.AllAccounts() {
|
|
if cmd.IncludeEmpty {
|
|
// Create an AddrData entry for each active address in the account.
|
|
// Otherwise we'll just get addresses from transactions later.
|
|
for _, address := range account.SortedActivePaymentAddresses() {
|
|
// There might be duplicates, just overwrite them.
|
|
allAddrData[address] = AddrData{account: account}
|
|
}
|
|
}
|
|
for _, record := range account.TxStore.Records() {
|
|
for _, credit := range record.Credits() {
|
|
confirmations := credit.Confirmations(bs.Height)
|
|
if !credit.Confirmed(cmd.MinConf, bs.Height) {
|
|
// Not enough confirmations, skip the current block.
|
|
continue
|
|
}
|
|
_, addresses, _, err := credit.Addresses(activeNet.Params)
|
|
if err != nil {
|
|
// Unusable address, skip it.
|
|
continue
|
|
}
|
|
for _, address := range addresses {
|
|
addrStr := address.EncodeAddress()
|
|
addrData, ok := allAddrData[addrStr]
|
|
if ok {
|
|
// Address already present, check account consistency.
|
|
if addrData.account != account {
|
|
return nil, fmt.Errorf(
|
|
"Address %v in both account %v and account %v",
|
|
addrStr, addrData.account.name, account.name)
|
|
}
|
|
addrData.amount += credit.Amount()
|
|
// Always overwrite confirmations with newer ones.
|
|
addrData.confirmations = confirmations
|
|
} else {
|
|
addrData = AddrData{
|
|
account: account,
|
|
amount: credit.Amount(),
|
|
confirmations: confirmations,
|
|
}
|
|
}
|
|
allAddrData[addrStr] = addrData
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Massage address data into output format.
|
|
numAddresses := len(allAddrData)
|
|
ret := make([]btcjson.ListReceivedByAddressResult, numAddresses, numAddresses)
|
|
idx := 0
|
|
for address, addrData := range allAddrData {
|
|
ret[idx] = btcjson.ListReceivedByAddressResult{
|
|
Account: addrData.account.name,
|
|
Address: address,
|
|
Amount: addrData.amount.ToUnit(btcutil.AmountBTC),
|
|
Confirmations: uint64(addrData.confirmations),
|
|
}
|
|
idx++
|
|
}
|
|
return ret, nil
|
|
}
|
|
|
|
// ListSinceBlock handles a listsinceblock request by returning an array of maps
|
|
// with details of sent and received wallet transactions since the given block.
|
|
func ListSinceBlock(icmd btcjson.Cmd) (interface{}, error) {
|
|
cmd, ok := icmd.(*btcjson.ListSinceBlockCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
rpcc, err := accessClient()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
height := int32(-1)
|
|
if cmd.BlockHash != "" {
|
|
hash, err := btcwire.NewShaHashFromStr(cmd.BlockHash)
|
|
if err != nil {
|
|
return nil, DeserializationError{err}
|
|
}
|
|
block, err := rpcc.GetBlock(hash)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
height = int32(block.Height())
|
|
}
|
|
|
|
bs, err := rpcc.BlockStamp()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// For the result we need the block hash for the last block counted
|
|
// in the blockchain due to confirmations. We send this off now so that
|
|
// it can arrive asynchronously while we figure out the rest.
|
|
gbh := rpcc.GetBlockHashAsync(int64(bs.Height) + 1 - int64(cmd.TargetConfirmations))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
txInfoList, err := AcctMgr.ListSinceBlock(height, bs.Height,
|
|
cmd.TargetConfirmations)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Done with work, get the response.
|
|
blockHash, err := gbh.Receive()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
res := btcjson.ListSinceBlockResult{
|
|
Transactions: txInfoList,
|
|
LastBlock: blockHash.String(),
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
// ListTransactions handles a listtransactions request by returning an
|
|
// array of maps with details of sent and recevied wallet transactions.
|
|
func ListTransactions(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.ListTransactionsCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
a, err := AcctMgr.Account(cmd.Account)
|
|
if err != nil {
|
|
if err == ErrNotFound {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
return a.ListTransactions(cmd.From, cmd.Count)
|
|
}
|
|
|
|
// ListAddressTransactions handles a listaddresstransactions request by
|
|
// returning an array of maps with details of spent and received wallet
|
|
// transactions. The form of the reply is identical to listtransactions,
|
|
// but the array elements are limited to transaction details which are
|
|
// about the addresess included in the request.
|
|
func ListAddressTransactions(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcws.ListAddressTransactionsCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
a, err := AcctMgr.Account(cmd.Account)
|
|
if err != nil {
|
|
if err == ErrNotFound {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
// Decode addresses.
|
|
pkHashMap := make(map[string]struct{})
|
|
for _, addrStr := range cmd.Addresses {
|
|
addr, err := btcutil.DecodeAddress(addrStr, activeNet.Params)
|
|
if err != nil {
|
|
return nil, btcjson.ErrInvalidAddressOrKey
|
|
}
|
|
apkh, ok := addr.(*btcutil.AddressPubKeyHash)
|
|
if !ok || !apkh.IsForNet(activeNet.Params) {
|
|
return nil, btcjson.ErrInvalidAddressOrKey
|
|
}
|
|
pkHashMap[string(addr.ScriptAddress())] = struct{}{}
|
|
}
|
|
|
|
return a.ListAddressTransactions(pkHashMap)
|
|
}
|
|
|
|
// ListAllTransactions handles a listalltransactions request by returning
|
|
// a map with details of sent and recevied wallet transactions. This is
|
|
// similar to ListTransactions, except it takes only a single optional
|
|
// argument for the account name and replies with all transactions.
|
|
func ListAllTransactions(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcws.ListAllTransactionsCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
a, err := AcctMgr.Account(cmd.Account)
|
|
if err != nil {
|
|
if err == ErrNotFound {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
return a.ListAllTransactions()
|
|
}
|
|
|
|
// ListUnspent handles the listunspent command.
|
|
func ListUnspent(icmd btcjson.Cmd) (interface{}, error) {
|
|
cmd, ok := icmd.(*btcjson.ListUnspentCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
addresses := make(map[string]bool)
|
|
if len(cmd.Addresses) != 0 {
|
|
// confirm that all of them are good:
|
|
for _, as := range cmd.Addresses {
|
|
a, err := btcutil.DecodeAddress(as, activeNet.Params)
|
|
if err != nil {
|
|
return nil, btcjson.ErrInvalidAddressOrKey
|
|
}
|
|
|
|
if _, ok := addresses[a.EncodeAddress()]; ok {
|
|
// duplicate
|
|
return nil, btcjson.ErrInvalidParameter
|
|
}
|
|
addresses[a.EncodeAddress()] = true
|
|
}
|
|
}
|
|
|
|
return AcctMgr.ListUnspent(cmd.MinConf, cmd.MaxConf, addresses)
|
|
}
|
|
|
|
// LockUnspent handles the lockunspent command.
|
|
func LockUnspent(icmd btcjson.Cmd) (interface{}, error) {
|
|
cmd, ok := icmd.(*btcjson.LockUnspentCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
// Due to our poor account support, this assumes only the default
|
|
// account is available. When the keystore and account heirarchies are
|
|
// reversed, the locked outpoints mapping will cover all accounts.
|
|
a, err := AcctMgr.Account("")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
switch {
|
|
case cmd.Unlock && len(cmd.Transactions) == 0:
|
|
a.ResetLockedOutpoints()
|
|
default:
|
|
for _, input := range cmd.Transactions {
|
|
txSha, err := btcwire.NewShaHashFromStr(input.Txid)
|
|
if err != nil {
|
|
return nil, ParseError{err}
|
|
}
|
|
op := btcwire.OutPoint{Hash: *txSha, Index: input.Vout}
|
|
if cmd.Unlock {
|
|
a.UnlockOutpoint(op)
|
|
} else {
|
|
a.LockOutpoint(op)
|
|
}
|
|
}
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
// sendPairs is a helper routine to reduce duplicated code when creating and
|
|
// sending payment transactions.
|
|
func sendPairs(icmd btcjson.Cmd, account string, amounts map[string]btcutil.Amount,
|
|
minconf int) (interface{}, error) {
|
|
|
|
rpcc, err := accessClient()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Check that the account specified in the request exists.
|
|
a, err := AcctMgr.Account(account)
|
|
if err != nil {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
|
|
// Create transaction, replying with an error if the creation
|
|
// was not successful.
|
|
createdTx, err := a.txToPairs(amounts, minconf)
|
|
if err != nil {
|
|
switch err {
|
|
case ErrNonPositiveAmount:
|
|
return nil, ErrNeedPositiveAmount
|
|
case keystore.ErrLocked:
|
|
return nil, btcjson.ErrWalletUnlockNeeded
|
|
default:
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
// If a change address was added, sync wallet to disk and request
|
|
// transaction notifications to the change address.
|
|
if createdTx.changeAddr != nil {
|
|
AcctMgr.ds.ScheduleWalletWrite(a)
|
|
if err := AcctMgr.ds.FlushAccount(a); err != nil {
|
|
return nil, fmt.Errorf("Cannot write account: %v", err)
|
|
}
|
|
err := rpcc.NotifyReceived([]btcutil.Address{createdTx.changeAddr})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
txSha, err := rpcc.SendRawTransaction(createdTx.tx.MsgTx(), false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := handleSendRawTxReply(icmd, txSha, a, createdTx); err != nil {
|
|
return nil, err
|
|
}
|
|
return txSha.String(), nil
|
|
}
|
|
|
|
// SendFrom handles a sendfrom RPC request by creating a new transaction
|
|
// spending unspent transaction outputs for a wallet to another payment
|
|
// address. Leftover inputs not sent to the payment address or a fee for
|
|
// the miner are sent back to a new address in the wallet. Upon success,
|
|
// the TxID for the created transaction is returned.
|
|
func SendFrom(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.SendFromCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
// Check that signed integer parameters are positive.
|
|
if cmd.Amount < 0 {
|
|
return nil, ErrNeedPositiveAmount
|
|
}
|
|
if cmd.MinConf < 0 {
|
|
return nil, ErrNeedPositiveMinconf
|
|
}
|
|
// Create map of address and amount pairs.
|
|
pairs := map[string]btcutil.Amount{
|
|
cmd.ToAddress: btcutil.Amount(cmd.Amount),
|
|
}
|
|
|
|
return sendPairs(cmd, cmd.FromAccount, pairs, cmd.MinConf)
|
|
}
|
|
|
|
// SendMany handles a sendmany RPC request by creating a new transaction
|
|
// spending unspent transaction outputs for a wallet to any number of
|
|
// payment addresses. Leftover inputs not sent to the payment address
|
|
// or a fee for the miner are sent back to a new address in the wallet.
|
|
// Upon success, the TxID for the created transaction is returned.
|
|
func SendMany(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.SendManyCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
// Check that minconf is positive.
|
|
if cmd.MinConf < 0 {
|
|
return nil, ErrNeedPositiveMinconf
|
|
}
|
|
|
|
// Recreate address/amount pairs, using btcutil.Amount.
|
|
pairs := make(map[string]btcutil.Amount, len(cmd.Amounts))
|
|
for k, v := range cmd.Amounts {
|
|
pairs[k] = btcutil.Amount(v)
|
|
}
|
|
|
|
return sendPairs(cmd, cmd.FromAccount, pairs, cmd.MinConf)
|
|
}
|
|
|
|
// SendToAddress handles a sendtoaddress RPC request by creating a new
|
|
// transaction spending unspent transaction outputs for a wallet to another
|
|
// payment address. Leftover inputs not sent to the payment address or a fee
|
|
// for the miner are sent back to a new address in the wallet. Upon success,
|
|
// the TxID for the created transaction is returned.
|
|
func SendToAddress(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.SendToAddressCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
// Check that signed integer parameters are positive.
|
|
if cmd.Amount < 0 {
|
|
return nil, ErrNeedPositiveAmount
|
|
}
|
|
|
|
// Mock up map of address and amount pairs.
|
|
pairs := map[string]btcutil.Amount{
|
|
cmd.Address: btcutil.Amount(cmd.Amount),
|
|
}
|
|
|
|
return sendPairs(cmd, "", pairs, 1)
|
|
}
|
|
|
|
func handleSendRawTxReply(icmd btcjson.Cmd, txSha *btcwire.ShaHash, a *Account, txInfo *CreatedTx) error {
|
|
// Add to transaction store.
|
|
txr, err := a.TxStore.InsertTx(txInfo.tx, nil)
|
|
if err != nil {
|
|
log.Errorf("Error adding sent tx history: %v", err)
|
|
return btcjson.ErrInternal
|
|
}
|
|
debits, err := txr.AddDebits(txInfo.inputs)
|
|
if err != nil {
|
|
log.Errorf("Error adding sent tx history: %v", err)
|
|
return btcjson.ErrInternal
|
|
}
|
|
AcctMgr.ds.ScheduleTxStoreWrite(a)
|
|
|
|
// Notify websocket clients of the transaction.
|
|
rpcc, err := accessClient()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if bs, err := rpcc.BlockStamp(); err == nil {
|
|
ltr, err := debits.ToJSON(a.KeyStore.Name(), bs.Height,
|
|
a.KeyStore.Net())
|
|
if err != nil {
|
|
log.Errorf("Error adding sent tx history: %v", err)
|
|
return btcjson.ErrInternal
|
|
}
|
|
for _, details := range ltr {
|
|
server.NotifyNewTxDetails(a.KeyStore.Name(), details)
|
|
}
|
|
}
|
|
|
|
// Disk sync tx and utxo stores.
|
|
if err := AcctMgr.ds.FlushAccount(a); err != nil {
|
|
log.Errorf("Cannot write account: %v", err)
|
|
return err
|
|
}
|
|
|
|
// Notify websocket clients of account's new unconfirmed and
|
|
// confirmed balance.
|
|
confirmed, err := a.CalculateBalance(1)
|
|
var unconfirmed btcutil.Amount
|
|
if err == nil {
|
|
unconfirmed, err = a.CalculateBalance(0)
|
|
}
|
|
if err != nil {
|
|
return err
|
|
}
|
|
unconfirmed -= confirmed
|
|
server.NotifyWalletBalance(a.name, confirmed)
|
|
server.NotifyWalletBalanceUnconfirmed(a.name, unconfirmed)
|
|
|
|
// The comments to be saved differ based on the underlying type
|
|
// of the cmd, so switch on the type to check whether it is a
|
|
// SendFromCmd or SendManyCmd.
|
|
//
|
|
// TODO(jrick): If message succeeded in being sent, save the
|
|
// transaction details with comments.
|
|
switch cmd := icmd.(type) {
|
|
case *btcjson.SendFromCmd:
|
|
_ = cmd.Comment
|
|
_ = cmd.CommentTo
|
|
|
|
case *btcjson.SendManyCmd:
|
|
_ = cmd.Comment
|
|
case *btcjson.SendToAddressCmd:
|
|
_ = cmd.Comment
|
|
_ = cmd.CommentTo
|
|
}
|
|
|
|
log.Infof("Successfully sent transaction %v", txSha)
|
|
return nil
|
|
}
|
|
|
|
// SetTxFee sets the transaction fee per kilobyte added to transactions.
|
|
func SetTxFee(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.SetTxFeeCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
// Check that amount is not negative.
|
|
if cmd.Amount < 0 {
|
|
return nil, ErrNeedPositiveAmount
|
|
}
|
|
|
|
// Lookup default account (which realistically is the only account
|
|
// that transactions can be made with at the moment) and set its
|
|
// fee increment field.
|
|
a, err := AcctMgr.Account("")
|
|
if err != nil {
|
|
return nil, ErrNoAccounts
|
|
}
|
|
a.FeeIncrement = btcutil.Amount(cmd.Amount)
|
|
|
|
// A boolean true result is returned upon success.
|
|
return true, nil
|
|
}
|
|
|
|
// SignMessage signs the given message with the private key for the given
|
|
// address
|
|
func SignMessage(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.SignMessageCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
addr, err := btcutil.DecodeAddress(cmd.Address, activeNet.Params)
|
|
if err != nil {
|
|
return nil, ParseError{err}
|
|
}
|
|
|
|
ainfo, err := AcctMgr.Address(addr)
|
|
if err != nil {
|
|
return nil, btcjson.ErrInvalidAddressOrKey
|
|
}
|
|
|
|
pka := ainfo.(keystore.PubKeyAddress)
|
|
privkey, err := pka.PrivKey()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
fullmsg := "Bitcoin Signed Message:\n" + cmd.Message
|
|
sigbytes, err := btcec.SignCompact(btcec.S256(), privkey,
|
|
btcwire.DoubleSha256([]byte(fullmsg)), ainfo.Compressed())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return base64.StdEncoding.EncodeToString(sigbytes), nil
|
|
}
|
|
|
|
// CreateEncryptedWallet creates a new account with an encrypted
|
|
// wallet. If an account with the same name as the requested account
|
|
// name already exists, an invalid account name error is returned to
|
|
// the client.
|
|
//
|
|
// Wallets will be created on TestNet3, or MainNet if btcwallet is run with
|
|
// the --mainnet option.
|
|
func CreateEncryptedWallet(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcws.CreateEncryptedWalletCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
err := AcctMgr.CreateEncryptedWallet([]byte(cmd.Passphrase))
|
|
if err != nil {
|
|
if err == ErrWalletExists {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
// A nil reply is sent upon successful wallet creation.
|
|
return nil, nil
|
|
}
|
|
|
|
// RecoverAddresses recovers the next n addresses from an account's wallet.
|
|
func RecoverAddresses(icmd btcjson.Cmd) (interface{}, error) {
|
|
cmd, ok := icmd.(*btcws.RecoverAddressesCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
a, err := AcctMgr.Account(cmd.Account)
|
|
if err != nil {
|
|
if err == ErrNotFound {
|
|
return nil, btcjson.ErrWalletInvalidAccountName
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
err = a.RecoverAddresses(cmd.N)
|
|
return nil, err
|
|
}
|
|
|
|
// pendingTx is used for async fetching of transaction dependancies in
|
|
// SignRawTransaction.
|
|
type pendingTx struct {
|
|
resp btcrpcclient.FutureGetRawTransactionResult
|
|
inputs []uint32 // list of inputs that care about this tx.
|
|
}
|
|
|
|
// SignRawTransaction handles the signrawtransaction command.
|
|
func SignRawTransaction(icmd btcjson.Cmd) (interface{}, error) {
|
|
cmd, ok := icmd.(*btcjson.SignRawTransactionCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
serializedTx, err := decodeHexStr(cmd.RawTx)
|
|
if err != nil {
|
|
return nil, btcjson.ErrDecodeHexString
|
|
}
|
|
msgTx := btcwire.NewMsgTx()
|
|
err = msgTx.Deserialize(bytes.NewBuffer(serializedTx))
|
|
if err != nil {
|
|
e := errors.New("TX decode failed")
|
|
return nil, DeserializationError{e}
|
|
}
|
|
|
|
// First we add the stuff we have been given.
|
|
// TODO(oga) really we probably should look these up with btcd anyway
|
|
// to make sure that they match the blockchain if present.
|
|
inputs := make(map[btcwire.OutPoint][]byte)
|
|
scripts := make(map[string][]byte)
|
|
for _, rti := range cmd.Inputs {
|
|
inputSha, err := btcwire.NewShaHashFromStr(rti.Txid)
|
|
if err != nil {
|
|
return nil, DeserializationError{err}
|
|
}
|
|
|
|
script, err := decodeHexStr(rti.ScriptPubKey)
|
|
if err != nil {
|
|
return nil, DeserializationError{err}
|
|
}
|
|
|
|
// redeemScript is only actually used iff the user provided
|
|
// private keys. In which case, it is used to get the scripts
|
|
// for signing. If the user did not provide keys then we always
|
|
// get scripts from the wallet.
|
|
// Empty strings are ok for this one and hex.DecodeString will
|
|
// DTRT.
|
|
if len(cmd.PrivKeys) != 0 {
|
|
redeemScript, err := decodeHexStr(rti.RedeemScript)
|
|
if err != nil {
|
|
return nil, DeserializationError{err}
|
|
}
|
|
|
|
addr, err := btcutil.NewAddressScriptHash(redeemScript,
|
|
activeNet.Params)
|
|
if err != nil {
|
|
return nil, DeserializationError{err}
|
|
}
|
|
scripts[addr.String()] = redeemScript
|
|
}
|
|
inputs[btcwire.OutPoint{
|
|
Hash: *inputSha,
|
|
Index: rti.Vout,
|
|
}] = script
|
|
}
|
|
|
|
var rpcc *rpcClient
|
|
|
|
// Now we go and look for any inputs that we were not provided by
|
|
// querying btcd with getrawtransaction. We queue up a bunch of async
|
|
// requests and will wait for replies after we have checked the rest of
|
|
// the arguments.
|
|
requested := make(map[btcwire.ShaHash]*pendingTx)
|
|
for _, txIn := range msgTx.TxIn {
|
|
// Did we get this txin from the arguments?
|
|
if _, ok := inputs[txIn.PreviousOutpoint]; ok {
|
|
continue
|
|
}
|
|
|
|
// Are we already fetching this tx? If so mark us as interested
|
|
// in this outpoint. (N.B. that any *sane* tx will only
|
|
// reference each outpoint once, since anything else is a double
|
|
// spend. We don't check this ourselves to save having to scan
|
|
// the array, it will fail later if so).
|
|
if ptx, ok := requested[txIn.PreviousOutpoint.Hash]; ok {
|
|
ptx.inputs = append(ptx.inputs,
|
|
txIn.PreviousOutpoint.Index)
|
|
continue
|
|
}
|
|
|
|
// Never heard of this one before, request it.
|
|
if rpcc == nil {
|
|
rpcc, err = accessClient()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
prevHash := &txIn.PreviousOutpoint.Hash
|
|
requested[txIn.PreviousOutpoint.Hash] = &pendingTx{
|
|
resp: rpcc.GetRawTransactionAsync(prevHash),
|
|
inputs: []uint32{txIn.PreviousOutpoint.Index},
|
|
}
|
|
}
|
|
|
|
// Parse list of private keys, if present. If there are any keys here
|
|
// they are the keys that we may use for signing. If empty we will
|
|
// use any keys known to us already.
|
|
var keys map[string]*btcutil.WIF
|
|
if len(cmd.PrivKeys) != 0 {
|
|
keys = make(map[string]*btcutil.WIF)
|
|
|
|
for _, key := range cmd.PrivKeys {
|
|
wif, err := btcutil.DecodeWIF(key)
|
|
if err != nil {
|
|
return nil, DeserializationError{err}
|
|
}
|
|
|
|
if !wif.IsForNet(activeNet.Params) {
|
|
s := "key network doesn't match wallet's"
|
|
return nil, DeserializationError{errors.New(s)}
|
|
}
|
|
|
|
addr, err := btcutil.NewAddressPubKey(wif.SerializePubKey(),
|
|
activeNet.Params)
|
|
if err != nil {
|
|
return nil, DeserializationError{err}
|
|
}
|
|
keys[addr.EncodeAddress()] = wif
|
|
}
|
|
}
|
|
|
|
hashType := btcscript.SigHashAll
|
|
if cmd.Flags != "" {
|
|
switch cmd.Flags {
|
|
case "ALL":
|
|
hashType = btcscript.SigHashAll
|
|
case "NONE":
|
|
hashType = btcscript.SigHashNone
|
|
case "SINGLE":
|
|
hashType = btcscript.SigHashSingle
|
|
case "ALL|ANYONECANPAY":
|
|
hashType = btcscript.SigHashAll |
|
|
btcscript.SigHashAnyOneCanPay
|
|
case "NONE|ANYONECANPAY":
|
|
hashType = btcscript.SigHashNone |
|
|
btcscript.SigHashAnyOneCanPay
|
|
case "SINGLE|ANYONECANPAY":
|
|
hashType = btcscript.SigHashSingle |
|
|
btcscript.SigHashAnyOneCanPay
|
|
default:
|
|
e := errors.New("Invalid sighash parameter")
|
|
return nil, InvalidParameterError{e}
|
|
}
|
|
}
|
|
|
|
// We have checked the rest of the args. now we can collect the async
|
|
// txs. TODO(oga) If we don't mind the possibility of wasting work we
|
|
// could move waiting to the following loop and be slightly more
|
|
// asynchronous.
|
|
for txid, ptx := range requested {
|
|
tx, err := ptx.resp.Receive()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for _, input := range ptx.inputs {
|
|
if input >= uint32(len(tx.MsgTx().TxOut)) {
|
|
e := fmt.Errorf("input %s:%d is not in tx",
|
|
txid.String(), input)
|
|
return nil, InvalidParameterError{e}
|
|
}
|
|
|
|
inputs[btcwire.OutPoint{
|
|
Hash: txid,
|
|
Index: input,
|
|
}] = tx.MsgTx().TxOut[input].PkScript
|
|
}
|
|
}
|
|
|
|
// All args collected. Now we can sign all the inputs that we can.
|
|
// `complete' denotes that we successfully signed all outputs and that
|
|
// all scripts will run to completion. This is returned as part of the
|
|
// reply.
|
|
complete := true
|
|
for i, txIn := range msgTx.TxIn {
|
|
input, ok := inputs[txIn.PreviousOutpoint]
|
|
if !ok {
|
|
// failure to find previous is actually an error since
|
|
// we failed above if we don't have all the inputs.
|
|
return nil, fmt.Errorf("%s:%d not found",
|
|
txIn.PreviousOutpoint.Hash,
|
|
txIn.PreviousOutpoint.Index)
|
|
}
|
|
|
|
// Set up our callbacks that we pass to btcscript so it can
|
|
// look up the appropriate keys and scripts by address.
|
|
getKey := btcscript.KeyClosure(func(addr btcutil.Address) (
|
|
*ecdsa.PrivateKey, bool, error) {
|
|
if len(keys) != 0 {
|
|
wif, ok := keys[addr.EncodeAddress()]
|
|
if !ok {
|
|
return nil, false,
|
|
errors.New("no key for address")
|
|
}
|
|
return wif.PrivKey.ToECDSA(), wif.CompressPubKey, nil
|
|
}
|
|
address, err := AcctMgr.Address(addr)
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
|
|
pka, ok := address.(keystore.PubKeyAddress)
|
|
if !ok {
|
|
return nil, false, errors.New("address is not " +
|
|
"a pubkey address")
|
|
}
|
|
|
|
key, err := pka.PrivKey()
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
|
|
return key, pka.Compressed(), nil
|
|
})
|
|
|
|
getScript := btcscript.ScriptClosure(func(
|
|
addr btcutil.Address) ([]byte, error) {
|
|
// If keys were provided then we can only use the
|
|
// scripts provided with our inputs, too.
|
|
if len(keys) != 0 {
|
|
script, ok := scripts[addr.EncodeAddress()]
|
|
if !ok {
|
|
return nil, errors.New("no script for " +
|
|
"address")
|
|
}
|
|
return script, nil
|
|
}
|
|
address, err := AcctMgr.Address(addr)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
sa, ok := address.(keystore.ScriptAddress)
|
|
if !ok {
|
|
return nil, errors.New("address is not a script" +
|
|
" address")
|
|
}
|
|
|
|
// TODO(oga) we could possible speed things up further
|
|
// by returning the addresses, class and nrequired here
|
|
// thus avoiding recomputing them.
|
|
return sa.Script(), nil
|
|
})
|
|
|
|
// SigHashSingle inputs can only be signed if there's a
|
|
// corresponding output. However this could be already signed,
|
|
// so we always verify the output.
|
|
if (hashType&btcscript.SigHashSingle) !=
|
|
btcscript.SigHashSingle || i < len(msgTx.TxOut) {
|
|
|
|
script, err := btcscript.SignTxOutput(activeNet.Params,
|
|
msgTx, i, input, byte(hashType), getKey,
|
|
getScript, txIn.SignatureScript)
|
|
// Failure to sign isn't an error, it just means that
|
|
// the tx isn't complete.
|
|
if err != nil {
|
|
complete = false
|
|
continue
|
|
}
|
|
txIn.SignatureScript = script
|
|
}
|
|
|
|
// Either it was already signed or we just signed it.
|
|
// Find out if it is completely satisfied or still needs more.
|
|
engine, err := btcscript.NewScript(txIn.SignatureScript, input,
|
|
i, msgTx, btcscript.ScriptBip16|
|
|
btcscript.ScriptCanonicalSignatures)
|
|
if err != nil || engine.Execute() != nil {
|
|
complete = false
|
|
}
|
|
}
|
|
|
|
buf := bytes.NewBuffer(nil)
|
|
buf.Grow(msgTx.SerializeSize())
|
|
|
|
// All returned errors (not OOM, which panics) encounted during
|
|
// bytes.Buffer writes are unexpected.
|
|
if err = msgTx.Serialize(buf); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
return btcjson.SignRawTransactionResult{
|
|
Hex: hex.EncodeToString(buf.Bytes()),
|
|
Complete: complete,
|
|
}, nil
|
|
}
|
|
|
|
// Stop handles the stop command by shutting down the process after the request
|
|
// is handled.
|
|
func Stop(icmd btcjson.Cmd) (interface{}, error) {
|
|
server.Stop()
|
|
return "btcwallet stopping.", nil
|
|
}
|
|
|
|
// ValidateAddress handles the validateaddress command.
|
|
func ValidateAddress(icmd btcjson.Cmd) (interface{}, error) {
|
|
cmd, ok := icmd.(*btcjson.ValidateAddressCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
result := btcjson.ValidateAddressResult{}
|
|
addr, err := btcutil.DecodeAddress(cmd.Address, activeNet.Params)
|
|
if err != nil {
|
|
// Use zero value (false) for IsValid.
|
|
return result, nil
|
|
}
|
|
|
|
// We could put whether or not the address is a script here,
|
|
// by checking the type of "addr", however, the reference
|
|
// implementation only puts that information if the script is
|
|
// "ismine", and we follow that behaviour.
|
|
result.Address = addr.EncodeAddress()
|
|
result.IsValid = true
|
|
|
|
// We can't use AcctMgr.Address() here since we also need the account
|
|
// name.
|
|
if account, err := AcctMgr.AccountByAddress(addr); err == nil {
|
|
// The address must be handled by this account, so we expect
|
|
// this call to succeed without error.
|
|
ainfo, err := account.KeyStore.Address(addr)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
result.IsMine = true
|
|
result.Account = account.name
|
|
|
|
if pka, ok := ainfo.(keystore.PubKeyAddress); ok {
|
|
result.IsCompressed = pka.Compressed()
|
|
result.PubKey = pka.ExportPubKey()
|
|
|
|
} else if sa, ok := ainfo.(keystore.ScriptAddress); ok {
|
|
result.IsScript = true
|
|
addresses := sa.Addresses()
|
|
addrStrings := make([]string, len(addresses))
|
|
for i, a := range addresses {
|
|
addrStrings[i] = a.EncodeAddress()
|
|
}
|
|
result.Addresses = addrStrings
|
|
result.Hex = hex.EncodeToString(sa.Script())
|
|
|
|
class := sa.ScriptClass()
|
|
// script type
|
|
result.Script = class.String()
|
|
if class == btcscript.MultiSigTy {
|
|
result.SigsRequired = int32(sa.RequiredSigs())
|
|
}
|
|
}
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// VerifyMessage handles the verifymessage command by verifying the provided
|
|
// compact signature for the given address and message.
|
|
func VerifyMessage(icmd btcjson.Cmd) (interface{}, error) {
|
|
cmd, ok := icmd.(*btcjson.VerifyMessageCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
addr, err := btcutil.DecodeAddress(cmd.Address, activeNet.Params)
|
|
if err != nil {
|
|
return nil, ParseError{err}
|
|
}
|
|
|
|
// First check we know about the address and get the keys.
|
|
ainfo, err := AcctMgr.Address(addr)
|
|
if err != nil {
|
|
return nil, btcjson.ErrInvalidAddressOrKey
|
|
}
|
|
|
|
pka := ainfo.(keystore.PubKeyAddress)
|
|
privkey, err := pka.PrivKey()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// decode base64 signature
|
|
sig, err := base64.StdEncoding.DecodeString(cmd.Signature)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Validate the signature - this just shows that it was valid at all.
|
|
// we will compare it with the key next.
|
|
pk, wasCompressed, err := btcec.RecoverCompact(btcec.S256(), sig,
|
|
btcwire.DoubleSha256([]byte("Bitcoin Signed Message:\n"+
|
|
cmd.Message)))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Return boolean if keys match.
|
|
return (pk.X.Cmp(privkey.X) == 0 && pk.Y.Cmp(privkey.Y) == 0 &&
|
|
ainfo.Compressed() == wasCompressed), nil
|
|
}
|
|
|
|
// WalletIsLocked handles the walletislocked extension request by
|
|
// returning the current lock state (false for unlocked, true for locked)
|
|
// of an account.
|
|
func WalletIsLocked(icmd btcjson.Cmd) (interface{}, error) {
|
|
return !<-AcctMgr.unlockedState, nil
|
|
}
|
|
|
|
// WalletLock handles a walletlock request by locking the all account
|
|
// wallets, returning an error if any wallet is not encrypted (for example,
|
|
// a watching-only wallet).
|
|
func WalletLock(icmd btcjson.Cmd) (interface{}, error) {
|
|
AcctMgr.LockWallets()
|
|
return nil, nil
|
|
}
|
|
|
|
// WalletPassphrase responds to the walletpassphrase request by unlocking
|
|
// the wallet. The decryption key is saved in the wallet until timeout
|
|
// seconds expires, after which the wallet is locked.
|
|
func WalletPassphrase(icmd btcjson.Cmd) (interface{}, error) {
|
|
// Type assert icmd to access parameters.
|
|
cmd, ok := icmd.(*btcjson.WalletPassphraseCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
timeout := time.Second * time.Duration(cmd.Timeout)
|
|
err := AcctMgr.UnlockWallets([]byte(cmd.Passphrase), timeout)
|
|
return nil, err
|
|
}
|
|
|
|
// WalletPassphraseChange responds to the walletpassphrasechange request
|
|
// by unlocking all accounts with the provided old passphrase, and
|
|
// re-encrypting each private key with an AES key derived from the new
|
|
// passphrase.
|
|
//
|
|
// If the old passphrase is correct and the passphrase is changed, all
|
|
// wallets will be immediately locked.
|
|
func WalletPassphraseChange(icmd btcjson.Cmd) (interface{}, error) {
|
|
cmd, ok := icmd.(*btcjson.WalletPassphraseChangeCmd)
|
|
if !ok {
|
|
return nil, btcjson.ErrInternal
|
|
}
|
|
|
|
err := AcctMgr.ChangePassphrase([]byte(cmd.OldPassphrase),
|
|
[]byte(cmd.NewPassphrase))
|
|
if err == keystore.ErrWrongPassphrase {
|
|
return nil, btcjson.ErrWalletPassphraseIncorrect
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
// AccountNtfn is a struct for marshalling any generic notification
|
|
// about a account for a websocket client.
|
|
//
|
|
// TODO(jrick): move to btcjson so it can be shared with clients?
|
|
type AccountNtfn struct {
|
|
Account string `json:"account"`
|
|
Notification interface{} `json:"notification"`
|
|
}
|
|
|
|
// NotifyWalletLockStateChange sends a notification to all websocket clients
|
|
// that the wallet has just been locked or unlocked.
|
|
func (s *rpcServer) NotifyWalletLockStateChange(account string, locked bool) {
|
|
ntfn := btcws.NewWalletLockStateNtfn(account, locked)
|
|
mntfn, err := ntfn.MarshalJSON()
|
|
// If the marshal failed, it indicates that the btcws notification
|
|
// struct contains a field with a type that is not marshalable.
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
select {
|
|
case s.broadcasts <- mntfn:
|
|
case <-s.quit:
|
|
}
|
|
}
|
|
|
|
// NotifyWalletBalance sends a confirmed account balance notification
|
|
// to all websocket clients.
|
|
func (s *rpcServer) NotifyWalletBalance(account string, balance btcutil.Amount) {
|
|
fbal := balance.ToUnit(btcutil.AmountBTC)
|
|
ntfn := btcws.NewAccountBalanceNtfn(account, fbal, true)
|
|
mntfn, err := ntfn.MarshalJSON()
|
|
// If the marshal failed, it indicates that the btcws notification
|
|
// struct contains a field with a type that is not marshalable.
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
select {
|
|
case s.broadcasts <- mntfn:
|
|
case <-s.quit:
|
|
}
|
|
}
|
|
|
|
// NotifyWalletBalanceUnconfirmed sends a confirmed account balance
|
|
// notification to all websocket clients.
|
|
func (s *rpcServer) NotifyWalletBalanceUnconfirmed(account string, balance btcutil.Amount) {
|
|
fbal := balance.ToUnit(btcutil.AmountBTC)
|
|
ntfn := btcws.NewAccountBalanceNtfn(account, fbal, false)
|
|
mntfn, err := ntfn.MarshalJSON()
|
|
// If the marshal failed, it indicates that the btcws notification
|
|
// struct contains a field with a type that is not marshalable.
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
select {
|
|
case s.broadcasts <- mntfn:
|
|
case <-s.quit:
|
|
}
|
|
}
|
|
|
|
// NotifyNewTxDetails sends details of a new transaction to all websocket
|
|
// clients.
|
|
func (s *rpcServer) NotifyNewTxDetails(account string, details btcjson.ListTransactionsResult) {
|
|
ntfn := btcws.NewTxNtfn(account, &details)
|
|
mntfn, err := ntfn.MarshalJSON()
|
|
// If the marshal failed, it indicates that the btcws notification
|
|
// struct contains a field with a type that is not marshalable.
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
select {
|
|
case s.broadcasts <- mntfn:
|
|
case <-s.quit:
|
|
}
|
|
}
|
|
|
|
// decodeHexStr decodes the hex encoding of a string, possibly prepending a
|
|
// leading '0' character if there is an odd number of bytes in the hex string.
|
|
// This is to prevent an error for an invalid hex string when using an odd
|
|
// number of bytes when calling hex.Decode.
|
|
func decodeHexStr(hexStr string) ([]byte, error) {
|
|
if len(hexStr)%2 != 0 {
|
|
hexStr = "0" + hexStr
|
|
}
|
|
return hex.DecodeString(hexStr)
|
|
}
|