github.com/alexanderbez/go-ethereum@v1.8.17-0.20181024144731-0a57b29f0c8e/cmd/faucet/faucet.go (about)

     1  // Copyright 2017 The go-ethereum Authors
     2  // This file is part of go-ethereum.
     3  //
     4  // go-ethereum is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // go-ethereum is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU General Public License
    15  // along with go-ethereum. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  // faucet is a Ether faucet backed by a light client.
    18  package main
    19  
    20  //go:generate go-bindata -nometadata -o website.go faucet.html
    21  //go:generate gofmt -w -s website.go
    22  
    23  import (
    24  	"bytes"
    25  	"context"
    26  	"encoding/json"
    27  	"errors"
    28  	"flag"
    29  	"fmt"
    30  	"html/template"
    31  	"io/ioutil"
    32  	"math"
    33  	"math/big"
    34  	"net/http"
    35  	"net/url"
    36  	"os"
    37  	"path/filepath"
    38  	"regexp"
    39  	"strconv"
    40  	"strings"
    41  	"sync"
    42  	"time"
    43  
    44  	"github.com/ethereum/go-ethereum/accounts"
    45  	"github.com/ethereum/go-ethereum/accounts/keystore"
    46  	"github.com/ethereum/go-ethereum/common"
    47  	"github.com/ethereum/go-ethereum/core"
    48  	"github.com/ethereum/go-ethereum/core/types"
    49  	"github.com/ethereum/go-ethereum/eth"
    50  	"github.com/ethereum/go-ethereum/eth/downloader"
    51  	"github.com/ethereum/go-ethereum/ethclient"
    52  	"github.com/ethereum/go-ethereum/ethstats"
    53  	"github.com/ethereum/go-ethereum/les"
    54  	"github.com/ethereum/go-ethereum/log"
    55  	"github.com/ethereum/go-ethereum/node"
    56  	"github.com/ethereum/go-ethereum/p2p"
    57  	"github.com/ethereum/go-ethereum/p2p/discover"
    58  	"github.com/ethereum/go-ethereum/p2p/discv5"
    59  	"github.com/ethereum/go-ethereum/p2p/nat"
    60  	"github.com/ethereum/go-ethereum/params"
    61  	"golang.org/x/net/websocket"
    62  )
    63  
    64  var (
    65  	genesisFlag = flag.String("genesis", "", "Genesis json file to seed the chain with")
    66  	apiPortFlag = flag.Int("apiport", 8080, "Listener port for the HTTP API connection")
    67  	ethPortFlag = flag.Int("ethport", 30303, "Listener port for the devp2p connection")
    68  	bootFlag    = flag.String("bootnodes", "", "Comma separated bootnode enode URLs to seed with")
    69  	netFlag     = flag.Uint64("network", 0, "Network ID to use for the Ethereum protocol")
    70  	statsFlag   = flag.String("ethstats", "", "Ethstats network monitoring auth string")
    71  
    72  	netnameFlag = flag.String("faucet.name", "", "Network name to assign to the faucet")
    73  	payoutFlag  = flag.Int("faucet.amount", 1, "Number of Ethers to pay out per user request")
    74  	minutesFlag = flag.Int("faucet.minutes", 1440, "Number of minutes to wait between funding rounds")
    75  	tiersFlag   = flag.Int("faucet.tiers", 3, "Number of funding tiers to enable (x3 time, x2.5 funds)")
    76  
    77  	accJSONFlag = flag.String("account.json", "", "Key json file to fund user requests with")
    78  	accPassFlag = flag.String("account.pass", "", "Decryption password to access faucet funds")
    79  
    80  	captchaToken  = flag.String("captcha.token", "", "Recaptcha site key to authenticate client side")
    81  	captchaSecret = flag.String("captcha.secret", "", "Recaptcha secret key to authenticate server side")
    82  
    83  	noauthFlag = flag.Bool("noauth", false, "Enables funding requests without authentication")
    84  	logFlag    = flag.Int("loglevel", 3, "Log level to use for Ethereum and the faucet")
    85  )
    86  
    87  var (
    88  	ether = new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)
    89  )
    90  
    91  func main() {
    92  	// Parse the flags and set up the logger to print everything requested
    93  	flag.Parse()
    94  	log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(*logFlag), log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
    95  
    96  	// Construct the payout tiers
    97  	amounts := make([]string, *tiersFlag)
    98  	periods := make([]string, *tiersFlag)
    99  	for i := 0; i < *tiersFlag; i++ {
   100  		// Calculate the amount for the next tier and format it
   101  		amount := float64(*payoutFlag) * math.Pow(2.5, float64(i))
   102  		amounts[i] = fmt.Sprintf("%s Ethers", strconv.FormatFloat(amount, 'f', -1, 64))
   103  		if amount == 1 {
   104  			amounts[i] = strings.TrimSuffix(amounts[i], "s")
   105  		}
   106  		// Calculate the period for the next tier and format it
   107  		period := *minutesFlag * int(math.Pow(3, float64(i)))
   108  		periods[i] = fmt.Sprintf("%d mins", period)
   109  		if period%60 == 0 {
   110  			period /= 60
   111  			periods[i] = fmt.Sprintf("%d hours", period)
   112  
   113  			if period%24 == 0 {
   114  				period /= 24
   115  				periods[i] = fmt.Sprintf("%d days", period)
   116  			}
   117  		}
   118  		if period == 1 {
   119  			periods[i] = strings.TrimSuffix(periods[i], "s")
   120  		}
   121  	}
   122  	// Load up and render the faucet website
   123  	tmpl, err := Asset("faucet.html")
   124  	if err != nil {
   125  		log.Crit("Failed to load the faucet template", "err", err)
   126  	}
   127  	website := new(bytes.Buffer)
   128  	err = template.Must(template.New("").Parse(string(tmpl))).Execute(website, map[string]interface{}{
   129  		"Network":   *netnameFlag,
   130  		"Amounts":   amounts,
   131  		"Periods":   periods,
   132  		"Recaptcha": *captchaToken,
   133  		"NoAuth":    *noauthFlag,
   134  	})
   135  	if err != nil {
   136  		log.Crit("Failed to render the faucet template", "err", err)
   137  	}
   138  	// Load and parse the genesis block requested by the user
   139  	blob, err := ioutil.ReadFile(*genesisFlag)
   140  	if err != nil {
   141  		log.Crit("Failed to read genesis block contents", "genesis", *genesisFlag, "err", err)
   142  	}
   143  	genesis := new(core.Genesis)
   144  	if err = json.Unmarshal(blob, genesis); err != nil {
   145  		log.Crit("Failed to parse genesis block json", "err", err)
   146  	}
   147  	// Convert the bootnodes to internal enode representations
   148  	var enodes []*discv5.Node
   149  	for _, boot := range strings.Split(*bootFlag, ",") {
   150  		if url, err := discv5.ParseNode(boot); err == nil {
   151  			enodes = append(enodes, url)
   152  		} else {
   153  			log.Error("Failed to parse bootnode URL", "url", boot, "err", err)
   154  		}
   155  	}
   156  	// Load up the account key and decrypt its password
   157  	if blob, err = ioutil.ReadFile(*accPassFlag); err != nil {
   158  		log.Crit("Failed to read account password contents", "file", *accPassFlag, "err", err)
   159  	}
   160  	// Delete trailing newline in password
   161  	pass := strings.TrimSuffix(string(blob), "\n")
   162  
   163  	ks := keystore.NewKeyStore(filepath.Join(os.Getenv("HOME"), ".faucet", "keys"), keystore.StandardScryptN, keystore.StandardScryptP)
   164  	if blob, err = ioutil.ReadFile(*accJSONFlag); err != nil {
   165  		log.Crit("Failed to read account key contents", "file", *accJSONFlag, "err", err)
   166  	}
   167  	acc, err := ks.Import(blob, pass, pass)
   168  	if err != nil {
   169  		log.Crit("Failed to import faucet signer account", "err", err)
   170  	}
   171  	ks.Unlock(acc, pass)
   172  
   173  	// Assemble and start the faucet light service
   174  	faucet, err := newFaucet(genesis, *ethPortFlag, enodes, *netFlag, *statsFlag, ks, website.Bytes())
   175  	if err != nil {
   176  		log.Crit("Failed to start faucet", "err", err)
   177  	}
   178  	defer faucet.close()
   179  
   180  	if err := faucet.listenAndServe(*apiPortFlag); err != nil {
   181  		log.Crit("Failed to launch faucet API", "err", err)
   182  	}
   183  }
   184  
   185  // request represents an accepted funding request.
   186  type request struct {
   187  	Avatar  string             `json:"avatar"`  // Avatar URL to make the UI nicer
   188  	Account common.Address     `json:"account"` // Ethereum address being funded
   189  	Time    time.Time          `json:"time"`    // Timestamp when the request was accepted
   190  	Tx      *types.Transaction `json:"tx"`      // Transaction funding the account
   191  }
   192  
   193  // faucet represents a crypto faucet backed by an Ethereum light client.
   194  type faucet struct {
   195  	config *params.ChainConfig // Chain configurations for signing
   196  	stack  *node.Node          // Ethereum protocol stack
   197  	client *ethclient.Client   // Client connection to the Ethereum chain
   198  	index  []byte              // Index page to serve up on the web
   199  
   200  	keystore *keystore.KeyStore // Keystore containing the single signer
   201  	account  accounts.Account   // Account funding user faucet requests
   202  	head     *types.Header      // Current head header of the faucet
   203  	balance  *big.Int           // Current balance of the faucet
   204  	nonce    uint64             // Current pending nonce of the faucet
   205  	price    *big.Int           // Current gas price to issue funds with
   206  
   207  	conns    []*websocket.Conn    // Currently live websocket connections
   208  	timeouts map[string]time.Time // History of users and their funding timeouts
   209  	reqs     []*request           // Currently pending funding requests
   210  	update   chan struct{}        // Channel to signal request updates
   211  
   212  	lock sync.RWMutex // Lock protecting the faucet's internals
   213  }
   214  
   215  func newFaucet(genesis *core.Genesis, port int, enodes []*discv5.Node, network uint64, stats string, ks *keystore.KeyStore, index []byte) (*faucet, error) {
   216  	// Assemble the raw devp2p protocol stack
   217  	stack, err := node.New(&node.Config{
   218  		Name:    "geth",
   219  		Version: params.VersionWithMeta,
   220  		DataDir: filepath.Join(os.Getenv("HOME"), ".faucet"),
   221  		P2P: p2p.Config{
   222  			NAT:              nat.Any(),
   223  			NoDiscovery:      true,
   224  			DiscoveryV5:      true,
   225  			ListenAddr:       fmt.Sprintf(":%d", port),
   226  			MaxPeers:         25,
   227  			BootstrapNodesV5: enodes,
   228  		},
   229  	})
   230  	if err != nil {
   231  		return nil, err
   232  	}
   233  	// Assemble the Ethereum light client protocol
   234  	if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
   235  		cfg := eth.DefaultConfig
   236  		cfg.SyncMode = downloader.LightSync
   237  		cfg.NetworkId = network
   238  		cfg.Genesis = genesis
   239  		return les.New(ctx, &cfg)
   240  	}); err != nil {
   241  		return nil, err
   242  	}
   243  	// Assemble the ethstats monitoring and reporting service'
   244  	if stats != "" {
   245  		if err := stack.Register(func(ctx *node.ServiceContext) (node.Service, error) {
   246  			var serv *les.LightEthereum
   247  			ctx.Service(&serv)
   248  			return ethstats.New(stats, nil, serv)
   249  		}); err != nil {
   250  			return nil, err
   251  		}
   252  	}
   253  	// Boot up the client and ensure it connects to bootnodes
   254  	if err := stack.Start(); err != nil {
   255  		return nil, err
   256  	}
   257  	for _, boot := range enodes {
   258  		old, _ := discover.ParseNode(boot.String())
   259  		stack.Server().AddPeer(old)
   260  	}
   261  	// Attach to the client and retrieve and interesting metadatas
   262  	api, err := stack.Attach()
   263  	if err != nil {
   264  		stack.Stop()
   265  		return nil, err
   266  	}
   267  	client := ethclient.NewClient(api)
   268  
   269  	return &faucet{
   270  		config:   genesis.Config,
   271  		stack:    stack,
   272  		client:   client,
   273  		index:    index,
   274  		keystore: ks,
   275  		account:  ks.Accounts()[0],
   276  		timeouts: make(map[string]time.Time),
   277  		update:   make(chan struct{}, 1),
   278  	}, nil
   279  }
   280  
   281  // close terminates the Ethereum connection and tears down the faucet.
   282  func (f *faucet) close() error {
   283  	return f.stack.Stop()
   284  }
   285  
   286  // listenAndServe registers the HTTP handlers for the faucet and boots it up
   287  // for service user funding requests.
   288  func (f *faucet) listenAndServe(port int) error {
   289  	go f.loop()
   290  
   291  	http.HandleFunc("/", f.webHandler)
   292  	http.Handle("/api", websocket.Handler(f.apiHandler))
   293  
   294  	return http.ListenAndServe(fmt.Sprintf(":%d", port), nil)
   295  }
   296  
   297  // webHandler handles all non-api requests, simply flattening and returning the
   298  // faucet website.
   299  func (f *faucet) webHandler(w http.ResponseWriter, r *http.Request) {
   300  	w.Write(f.index)
   301  }
   302  
   303  // apiHandler handles requests for Ether grants and transaction statuses.
   304  func (f *faucet) apiHandler(conn *websocket.Conn) {
   305  	// Start tracking the connection and drop at the end
   306  	defer conn.Close()
   307  
   308  	f.lock.Lock()
   309  	f.conns = append(f.conns, conn)
   310  	f.lock.Unlock()
   311  
   312  	defer func() {
   313  		f.lock.Lock()
   314  		for i, c := range f.conns {
   315  			if c == conn {
   316  				f.conns = append(f.conns[:i], f.conns[i+1:]...)
   317  				break
   318  			}
   319  		}
   320  		f.lock.Unlock()
   321  	}()
   322  	// Gather the initial stats from the network to report
   323  	var (
   324  		head    *types.Header
   325  		balance *big.Int
   326  		nonce   uint64
   327  		err     error
   328  	)
   329  	for head == nil || balance == nil {
   330  		// Retrieve the current stats cached by the faucet
   331  		f.lock.RLock()
   332  		if f.head != nil {
   333  			head = types.CopyHeader(f.head)
   334  		}
   335  		if f.balance != nil {
   336  			balance = new(big.Int).Set(f.balance)
   337  		}
   338  		nonce = f.nonce
   339  		f.lock.RUnlock()
   340  
   341  		if head == nil || balance == nil {
   342  			// Report the faucet offline until initial stats are ready
   343  			if err = sendError(conn, errors.New("Faucet offline")); err != nil {
   344  				log.Warn("Failed to send faucet error to client", "err", err)
   345  				return
   346  			}
   347  			time.Sleep(3 * time.Second)
   348  		}
   349  	}
   350  	// Send over the initial stats and the latest header
   351  	if err = send(conn, map[string]interface{}{
   352  		"funds":    new(big.Int).Div(balance, ether),
   353  		"funded":   nonce,
   354  		"peers":    f.stack.Server().PeerCount(),
   355  		"requests": f.reqs,
   356  	}, 3*time.Second); err != nil {
   357  		log.Warn("Failed to send initial stats to client", "err", err)
   358  		return
   359  	}
   360  	if err = send(conn, head, 3*time.Second); err != nil {
   361  		log.Warn("Failed to send initial header to client", "err", err)
   362  		return
   363  	}
   364  	// Keep reading requests from the websocket until the connection breaks
   365  	for {
   366  		// Fetch the next funding request and validate against github
   367  		var msg struct {
   368  			URL     string `json:"url"`
   369  			Tier    uint   `json:"tier"`
   370  			Captcha string `json:"captcha"`
   371  		}
   372  		if err = websocket.JSON.Receive(conn, &msg); err != nil {
   373  			return
   374  		}
   375  		if !*noauthFlag && !strings.HasPrefix(msg.URL, "https://gist.github.com/") && !strings.HasPrefix(msg.URL, "https://twitter.com/") &&
   376  			!strings.HasPrefix(msg.URL, "https://plus.google.com/") && !strings.HasPrefix(msg.URL, "https://www.facebook.com/") {
   377  			if err = sendError(conn, errors.New("URL doesn't link to supported services")); err != nil {
   378  				log.Warn("Failed to send URL error to client", "err", err)
   379  				return
   380  			}
   381  			continue
   382  		}
   383  		if msg.Tier >= uint(*tiersFlag) {
   384  			if err = sendError(conn, errors.New("Invalid funding tier requested")); err != nil {
   385  				log.Warn("Failed to send tier error to client", "err", err)
   386  				return
   387  			}
   388  			continue
   389  		}
   390  		log.Info("Faucet funds requested", "url", msg.URL, "tier", msg.Tier)
   391  
   392  		// If captcha verifications are enabled, make sure we're not dealing with a robot
   393  		if *captchaToken != "" {
   394  			form := url.Values{}
   395  			form.Add("secret", *captchaSecret)
   396  			form.Add("response", msg.Captcha)
   397  
   398  			res, err := http.PostForm("https://www.google.com/recaptcha/api/siteverify", form)
   399  			if err != nil {
   400  				if err = sendError(conn, err); err != nil {
   401  					log.Warn("Failed to send captcha post error to client", "err", err)
   402  					return
   403  				}
   404  				continue
   405  			}
   406  			var result struct {
   407  				Success bool            `json:"success"`
   408  				Errors  json.RawMessage `json:"error-codes"`
   409  			}
   410  			err = json.NewDecoder(res.Body).Decode(&result)
   411  			res.Body.Close()
   412  			if err != nil {
   413  				if err = sendError(conn, err); err != nil {
   414  					log.Warn("Failed to send captcha decode error to client", "err", err)
   415  					return
   416  				}
   417  				continue
   418  			}
   419  			if !result.Success {
   420  				log.Warn("Captcha verification failed", "err", string(result.Errors))
   421  				if err = sendError(conn, errors.New("Beep-bop, you're a robot!")); err != nil {
   422  					log.Warn("Failed to send captcha failure to client", "err", err)
   423  					return
   424  				}
   425  				continue
   426  			}
   427  		}
   428  		// Retrieve the Ethereum address to fund, the requesting user and a profile picture
   429  		var (
   430  			username string
   431  			avatar   string
   432  			address  common.Address
   433  		)
   434  		switch {
   435  		case strings.HasPrefix(msg.URL, "https://gist.github.com/"):
   436  			if err = sendError(conn, errors.New("GitHub authentication discontinued at the official request of GitHub")); err != nil {
   437  				log.Warn("Failed to send GitHub deprecation to client", "err", err)
   438  				return
   439  			}
   440  			continue
   441  		case strings.HasPrefix(msg.URL, "https://twitter.com/"):
   442  			username, avatar, address, err = authTwitter(msg.URL)
   443  		case strings.HasPrefix(msg.URL, "https://plus.google.com/"):
   444  			username, avatar, address, err = authGooglePlus(msg.URL)
   445  		case strings.HasPrefix(msg.URL, "https://www.facebook.com/"):
   446  			username, avatar, address, err = authFacebook(msg.URL)
   447  		case *noauthFlag:
   448  			username, avatar, address, err = authNoAuth(msg.URL)
   449  		default:
   450  			err = errors.New("Something funky happened, please open an issue at https://github.com/ethereum/go-ethereum/issues")
   451  		}
   452  		if err != nil {
   453  			if err = sendError(conn, err); err != nil {
   454  				log.Warn("Failed to send prefix error to client", "err", err)
   455  				return
   456  			}
   457  			continue
   458  		}
   459  		log.Info("Faucet request valid", "url", msg.URL, "tier", msg.Tier, "user", username, "address", address)
   460  
   461  		// Ensure the user didn't request funds too recently
   462  		f.lock.Lock()
   463  		var (
   464  			fund    bool
   465  			timeout time.Time
   466  		)
   467  		if timeout = f.timeouts[username]; time.Now().After(timeout) {
   468  			// User wasn't funded recently, create the funding transaction
   469  			amount := new(big.Int).Mul(big.NewInt(int64(*payoutFlag)), ether)
   470  			amount = new(big.Int).Mul(amount, new(big.Int).Exp(big.NewInt(5), big.NewInt(int64(msg.Tier)), nil))
   471  			amount = new(big.Int).Div(amount, new(big.Int).Exp(big.NewInt(2), big.NewInt(int64(msg.Tier)), nil))
   472  
   473  			tx := types.NewTransaction(f.nonce+uint64(len(f.reqs)), address, amount, 21000, f.price, nil)
   474  			signed, err := f.keystore.SignTx(f.account, tx, f.config.ChainID)
   475  			if err != nil {
   476  				f.lock.Unlock()
   477  				if err = sendError(conn, err); err != nil {
   478  					log.Warn("Failed to send transaction creation error to client", "err", err)
   479  					return
   480  				}
   481  				continue
   482  			}
   483  			// Submit the transaction and mark as funded if successful
   484  			if err := f.client.SendTransaction(context.Background(), signed); err != nil {
   485  				f.lock.Unlock()
   486  				if err = sendError(conn, err); err != nil {
   487  					log.Warn("Failed to send transaction transmission error to client", "err", err)
   488  					return
   489  				}
   490  				continue
   491  			}
   492  			f.reqs = append(f.reqs, &request{
   493  				Avatar:  avatar,
   494  				Account: address,
   495  				Time:    time.Now(),
   496  				Tx:      signed,
   497  			})
   498  			f.timeouts[username] = time.Now().Add(time.Duration(*minutesFlag*int(math.Pow(3, float64(msg.Tier)))) * time.Minute)
   499  			fund = true
   500  		}
   501  		f.lock.Unlock()
   502  
   503  		// Send an error if too frequent funding, othewise a success
   504  		if !fund {
   505  			if err = sendError(conn, fmt.Errorf("%s left until next allowance", common.PrettyDuration(timeout.Sub(time.Now())))); err != nil { // nolint: gosimple
   506  				log.Warn("Failed to send funding error to client", "err", err)
   507  				return
   508  			}
   509  			continue
   510  		}
   511  		if err = sendSuccess(conn, fmt.Sprintf("Funding request accepted for %s into %s", username, address.Hex())); err != nil {
   512  			log.Warn("Failed to send funding success to client", "err", err)
   513  			return
   514  		}
   515  		select {
   516  		case f.update <- struct{}{}:
   517  		default:
   518  		}
   519  	}
   520  }
   521  
   522  // refresh attempts to retrieve the latest header from the chain and extract the
   523  // associated faucet balance and nonce for connectivity caching.
   524  func (f *faucet) refresh(head *types.Header) error {
   525  	// Ensure a state update does not run for too long
   526  	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
   527  	defer cancel()
   528  
   529  	// If no header was specified, use the current chain head
   530  	var err error
   531  	if head == nil {
   532  		if head, err = f.client.HeaderByNumber(ctx, nil); err != nil {
   533  			return err
   534  		}
   535  	}
   536  	// Retrieve the balance, nonce and gas price from the current head
   537  	var (
   538  		balance *big.Int
   539  		nonce   uint64
   540  		price   *big.Int
   541  	)
   542  	if balance, err = f.client.BalanceAt(ctx, f.account.Address, head.Number); err != nil {
   543  		return err
   544  	}
   545  	if nonce, err = f.client.NonceAt(ctx, f.account.Address, head.Number); err != nil {
   546  		return err
   547  	}
   548  	if price, err = f.client.SuggestGasPrice(ctx); err != nil {
   549  		return err
   550  	}
   551  	// Everything succeeded, update the cached stats and eject old requests
   552  	f.lock.Lock()
   553  	f.head, f.balance = head, balance
   554  	f.price, f.nonce = price, nonce
   555  	for len(f.reqs) > 0 && f.reqs[0].Tx.Nonce() < f.nonce {
   556  		f.reqs = f.reqs[1:]
   557  	}
   558  	f.lock.Unlock()
   559  
   560  	return nil
   561  }
   562  
   563  // loop keeps waiting for interesting events and pushes them out to connected
   564  // websockets.
   565  func (f *faucet) loop() {
   566  	// Wait for chain events and push them to clients
   567  	heads := make(chan *types.Header, 16)
   568  	sub, err := f.client.SubscribeNewHead(context.Background(), heads)
   569  	if err != nil {
   570  		log.Crit("Failed to subscribe to head events", "err", err)
   571  	}
   572  	defer sub.Unsubscribe()
   573  
   574  	// Start a goroutine to update the state from head notifications in the background
   575  	update := make(chan *types.Header)
   576  
   577  	go func() {
   578  		for head := range update {
   579  			// New chain head arrived, query the current stats and stream to clients
   580  			timestamp := time.Unix(head.Time.Int64(), 0)
   581  			if time.Since(timestamp) > time.Hour {
   582  				log.Warn("Skipping faucet refresh, head too old", "number", head.Number, "hash", head.Hash(), "age", common.PrettyAge(timestamp))
   583  				continue
   584  			}
   585  			if err := f.refresh(head); err != nil {
   586  				log.Warn("Failed to update faucet state", "block", head.Number, "hash", head.Hash(), "err", err)
   587  				continue
   588  			}
   589  			// Faucet state retrieved, update locally and send to clients
   590  			f.lock.RLock()
   591  			log.Info("Updated faucet state", "number", head.Number, "hash", head.Hash(), "age", common.PrettyAge(timestamp), "balance", f.balance, "nonce", f.nonce, "price", f.price)
   592  
   593  			balance := new(big.Int).Div(f.balance, ether)
   594  			peers := f.stack.Server().PeerCount()
   595  
   596  			for _, conn := range f.conns {
   597  				if err := send(conn, map[string]interface{}{
   598  					"funds":    balance,
   599  					"funded":   f.nonce,
   600  					"peers":    peers,
   601  					"requests": f.reqs,
   602  				}, time.Second); err != nil {
   603  					log.Warn("Failed to send stats to client", "err", err)
   604  					conn.Close()
   605  					continue
   606  				}
   607  				if err := send(conn, head, time.Second); err != nil {
   608  					log.Warn("Failed to send header to client", "err", err)
   609  					conn.Close()
   610  				}
   611  			}
   612  			f.lock.RUnlock()
   613  		}
   614  	}()
   615  	// Wait for various events and assing to the appropriate background threads
   616  	for {
   617  		select {
   618  		case head := <-heads:
   619  			// New head arrived, send if for state update if there's none running
   620  			select {
   621  			case update <- head:
   622  			default:
   623  			}
   624  
   625  		case <-f.update:
   626  			// Pending requests updated, stream to clients
   627  			f.lock.RLock()
   628  			for _, conn := range f.conns {
   629  				if err := send(conn, map[string]interface{}{"requests": f.reqs}, time.Second); err != nil {
   630  					log.Warn("Failed to send requests to client", "err", err)
   631  					conn.Close()
   632  				}
   633  			}
   634  			f.lock.RUnlock()
   635  		}
   636  	}
   637  }
   638  
   639  // sends transmits a data packet to the remote end of the websocket, but also
   640  // setting a write deadline to prevent waiting forever on the node.
   641  func send(conn *websocket.Conn, value interface{}, timeout time.Duration) error {
   642  	if timeout == 0 {
   643  		timeout = 60 * time.Second
   644  	}
   645  	conn.SetWriteDeadline(time.Now().Add(timeout))
   646  	return websocket.JSON.Send(conn, value)
   647  }
   648  
   649  // sendError transmits an error to the remote end of the websocket, also setting
   650  // the write deadline to 1 second to prevent waiting forever.
   651  func sendError(conn *websocket.Conn, err error) error {
   652  	return send(conn, map[string]string{"error": err.Error()}, time.Second)
   653  }
   654  
   655  // sendSuccess transmits a success message to the remote end of the websocket, also
   656  // setting the write deadline to 1 second to prevent waiting forever.
   657  func sendSuccess(conn *websocket.Conn, msg string) error {
   658  	return send(conn, map[string]string{"success": msg}, time.Second)
   659  }
   660  
   661  // authTwitter tries to authenticate a faucet request using Twitter posts, returning
   662  // the username, avatar URL and Ethereum address to fund on success.
   663  func authTwitter(url string) (string, string, common.Address, error) {
   664  	// Ensure the user specified a meaningful URL, no fancy nonsense
   665  	parts := strings.Split(url, "/")
   666  	if len(parts) < 4 || parts[len(parts)-2] != "status" {
   667  		return "", "", common.Address{}, errors.New("Invalid Twitter status URL")
   668  	}
   669  	// Twitter's API isn't really friendly with direct links. Still, we don't
   670  	// want to do ask read permissions from users, so just load the public posts and
   671  	// scrape it for the Ethereum address and profile URL.
   672  	res, err := http.Get(url)
   673  	if err != nil {
   674  		return "", "", common.Address{}, err
   675  	}
   676  	defer res.Body.Close()
   677  
   678  	// Resolve the username from the final redirect, no intermediate junk
   679  	parts = strings.Split(res.Request.URL.String(), "/")
   680  	if len(parts) < 4 || parts[len(parts)-2] != "status" {
   681  		return "", "", common.Address{}, errors.New("Invalid Twitter status URL")
   682  	}
   683  	username := parts[len(parts)-3]
   684  
   685  	body, err := ioutil.ReadAll(res.Body)
   686  	if err != nil {
   687  		return "", "", common.Address{}, err
   688  	}
   689  	address := common.HexToAddress(string(regexp.MustCompile("0x[0-9a-fA-F]{40}").Find(body)))
   690  	if address == (common.Address{}) {
   691  		return "", "", common.Address{}, errors.New("No Ethereum address found to fund")
   692  	}
   693  	var avatar string
   694  	if parts = regexp.MustCompile("src=\"([^\"]+twimg.com/profile_images[^\"]+)\"").FindStringSubmatch(string(body)); len(parts) == 2 {
   695  		avatar = parts[1]
   696  	}
   697  	return username + "@twitter", avatar, address, nil
   698  }
   699  
   700  // authGooglePlus tries to authenticate a faucet request using GooglePlus posts,
   701  // returning the username, avatar URL and Ethereum address to fund on success.
   702  func authGooglePlus(url string) (string, string, common.Address, error) {
   703  	// Ensure the user specified a meaningful URL, no fancy nonsense
   704  	parts := strings.Split(url, "/")
   705  	if len(parts) < 4 || parts[len(parts)-2] != "posts" {
   706  		return "", "", common.Address{}, errors.New("Invalid Google+ post URL")
   707  	}
   708  	username := parts[len(parts)-3]
   709  
   710  	// Google's API isn't really friendly with direct links. Still, we don't
   711  	// want to do ask read permissions from users, so just load the public posts and
   712  	// scrape it for the Ethereum address and profile URL.
   713  	res, err := http.Get(url)
   714  	if err != nil {
   715  		return "", "", common.Address{}, err
   716  	}
   717  	defer res.Body.Close()
   718  
   719  	body, err := ioutil.ReadAll(res.Body)
   720  	if err != nil {
   721  		return "", "", common.Address{}, err
   722  	}
   723  	address := common.HexToAddress(string(regexp.MustCompile("0x[0-9a-fA-F]{40}").Find(body)))
   724  	if address == (common.Address{}) {
   725  		return "", "", common.Address{}, errors.New("No Ethereum address found to fund")
   726  	}
   727  	var avatar string
   728  	if parts = regexp.MustCompile("src=\"([^\"]+googleusercontent.com[^\"]+photo.jpg)\"").FindStringSubmatch(string(body)); len(parts) == 2 {
   729  		avatar = parts[1]
   730  	}
   731  	return username + "@google+", avatar, address, nil
   732  }
   733  
   734  // authFacebook tries to authenticate a faucet request using Facebook posts,
   735  // returning the username, avatar URL and Ethereum address to fund on success.
   736  func authFacebook(url string) (string, string, common.Address, error) {
   737  	// Ensure the user specified a meaningful URL, no fancy nonsense
   738  	parts := strings.Split(url, "/")
   739  	if len(parts) < 4 || parts[len(parts)-2] != "posts" {
   740  		return "", "", common.Address{}, errors.New("Invalid Facebook post URL")
   741  	}
   742  	username := parts[len(parts)-3]
   743  
   744  	// Facebook's Graph API isn't really friendly with direct links. Still, we don't
   745  	// want to do ask read permissions from users, so just load the public posts and
   746  	// scrape it for the Ethereum address and profile URL.
   747  	res, err := http.Get(url)
   748  	if err != nil {
   749  		return "", "", common.Address{}, err
   750  	}
   751  	defer res.Body.Close()
   752  
   753  	body, err := ioutil.ReadAll(res.Body)
   754  	if err != nil {
   755  		return "", "", common.Address{}, err
   756  	}
   757  	address := common.HexToAddress(string(regexp.MustCompile("0x[0-9a-fA-F]{40}").Find(body)))
   758  	if address == (common.Address{}) {
   759  		return "", "", common.Address{}, errors.New("No Ethereum address found to fund")
   760  	}
   761  	var avatar string
   762  	if parts = regexp.MustCompile("src=\"([^\"]+fbcdn.net[^\"]+)\"").FindStringSubmatch(string(body)); len(parts) == 2 {
   763  		avatar = parts[1]
   764  	}
   765  	return username + "@facebook", avatar, address, nil
   766  }
   767  
   768  // authNoAuth tries to interpret a faucet request as a plain Ethereum address,
   769  // without actually performing any remote authentication. This mode is prone to
   770  // Byzantine attack, so only ever use for truly private networks.
   771  func authNoAuth(url string) (string, string, common.Address, error) {
   772  	address := common.HexToAddress(regexp.MustCompile("0x[0-9a-fA-F]{40}").FindString(url))
   773  	if address == (common.Address{}) {
   774  		return "", "", common.Address{}, errors.New("No Ethereum address found to fund")
   775  	}
   776  	return address.Hex() + "@noauth", "", address, nil
   777  }