lotus/cmd/lotus-fountain/main.go

228 lines
5.1 KiB
Go
Raw Normal View History

2019-09-20 21:27:40 +00:00
package main
import (
"context"
"fmt"
"html/template"
"net"
2019-09-20 21:27:40 +00:00
"net/http"
"os"
"time"
2019-09-20 21:27:40 +00:00
2019-10-13 07:33:25 +00:00
rice "github.com/GeertJohan/go.rice"
logging "github.com/ipfs/go-log/v2"
"github.com/urfave/cli/v2"
2020-06-05 22:59:01 +00:00
"golang.org/x/xerrors"
2019-09-20 21:27:40 +00:00
"github.com/filecoin-project/go-address"
2022-06-14 15:00:51 +00:00
2021-04-05 18:12:47 +00:00
"github.com/filecoin-project/lotus/api/v0api"
"github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/chain/types"
lcli "github.com/filecoin-project/lotus/cli"
2019-09-20 21:27:40 +00:00
)
var log = logging.Logger("main")
func main() {
logging.SetLogLevel("*", "INFO")
log.Info("Starting fountain")
local := []*cli.Command{
runCmd,
}
app := &cli.App{
Name: "lotus-fountain",
Usage: "Devnet token distribution utility",
2020-06-01 18:43:51 +00:00
Version: build.UserVersion(),
2019-09-20 21:27:40 +00:00
Flags: []cli.Flag{
&cli.StringFlag{
Name: "repo",
EnvVars: []string{"LOTUS_PATH"},
Value: "~/.lotus", // TODO: Consider XDG_DATA_HOME
},
},
Commands: local,
}
if err := app.Run(os.Args); err != nil {
log.Warn(err)
return
}
}
var runCmd = &cli.Command{
Name: "run",
Usage: "Start lotus fountain",
Flags: []cli.Flag{
&cli.StringFlag{
Name: "front",
Value: "127.0.0.1:7777",
},
&cli.StringFlag{
Name: "from",
},
&cli.StringFlag{
Name: "amount",
EnvVars: []string{"LOTUS_FOUNTAIN_AMOUNT"},
Value: "50",
},
&cli.Float64Flag{
Name: "captcha-threshold",
Value: 0.5,
},
2019-09-20 21:27:40 +00:00
},
Action: func(cctx *cli.Context) error {
sendPerRequest, err := types.ParseFIL(cctx.String("amount"))
if err != nil {
return err
}
2019-10-04 22:43:04 +00:00
nodeApi, closer, err := lcli.GetFullNodeAPI(cctx)
2019-09-20 21:27:40 +00:00
if err != nil {
return err
}
2019-10-04 16:02:25 +00:00
defer closer()
2019-09-20 21:27:40 +00:00
ctx := lcli.ReqContext(cctx)
v, err := nodeApi.Version(ctx)
if err != nil {
return err
}
2020-11-24 11:09:48 +00:00
log.Infof("Remote version: %s", v.Version)
2019-09-20 21:27:40 +00:00
from, err := address.NewFromString(cctx.String("from"))
if err != nil {
return xerrors.Errorf("parsing source address (provide correct --from flag!): %w", err)
}
h := &handler{
ctx: ctx,
api: nodeApi,
from: from,
sendPerRequest: sendPerRequest,
limiter: NewLimiter(LimiterConfig{
2020-07-29 01:22:29 +00:00
TotalRate: 500 * time.Millisecond,
TotalBurst: build.BlockMessageLimit,
IPRate: 10 * time.Minute,
IPBurst: 5,
2019-10-17 14:28:03 +00:00
WalletRate: 15 * time.Minute,
WalletBurst: 2,
}),
2021-02-17 00:19:27 +00:00
recapThreshold: cctx.Float64("captcha-threshold"),
2019-09-20 21:27:40 +00:00
}
box := rice.MustFindBox("site")
http.Handle("/", http.FileServer(box.HTTPBox()))
http.HandleFunc("/funds.html", prepFundsHtml(box))
http.Handle("/send", h)
2019-09-20 21:27:40 +00:00
fmt.Printf("Open http://%s\n", cctx.String("front"))
go func() {
<-ctx.Done()
os.Exit(0)
}()
return http.ListenAndServe(cctx.String("front"), nil)
},
}
func prepFundsHtml(box *rice.Box) http.HandlerFunc {
tmpl := template.Must(template.New("funds").Parse(box.MustString("funds.html")))
return func(w http.ResponseWriter, r *http.Request) {
err := tmpl.Execute(w, os.Getenv("RECAPTCHA_SITE_KEY"))
if err != nil {
http.Error(w, err.Error(), http.StatusBadGateway)
return
}
}
}
2019-09-20 21:27:40 +00:00
type handler struct {
ctx context.Context
2021-04-05 18:12:47 +00:00
api v0api.FullNode
2019-09-20 21:27:40 +00:00
from address.Address
sendPerRequest types.FIL
2021-02-17 00:19:27 +00:00
limiter *Limiter
recapThreshold float64
2019-09-20 21:27:40 +00:00
}
func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
http.Error(w, "only POST is allowed", http.StatusBadRequest)
return
}
reqIP := r.Header.Get("X-Real-IP")
if reqIP == "" {
h, _, err := net.SplitHostPort(r.RemoteAddr)
if err != nil {
log.Errorf("could not get ip from: %s, err: %s", r.RemoteAddr, err)
}
reqIP = h
}
capResp, err := VerifyToken(r.FormValue("g-recaptcha-response"), reqIP)
if err != nil {
http.Error(w, err.Error(), http.StatusBadGateway)
return
}
2021-02-17 00:19:27 +00:00
if !capResp.Success || capResp.Score < h.recapThreshold {
log.Infow("spam", "capResp", capResp)
http.Error(w, "spam protection", http.StatusUnprocessableEntity)
return
}
to, err := address.NewFromString(r.FormValue("address"))
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
if to == address.Undef {
http.Error(w, "empty address", http.StatusBadRequest)
return
}
// Limit based on wallet address
limiter := h.limiter.GetWalletLimiter(to.String())
if !limiter.Allow() {
http.Error(w, http.StatusText(http.StatusTooManyRequests)+": wallet limit", http.StatusTooManyRequests)
return
}
// Limit based on IP
if i := net.ParseIP(reqIP); i != nil && i.IsLoopback() {
log.Errorf("rate limiting localhost: %s", reqIP)
}
limiter = h.limiter.GetIPLimiter(reqIP)
if !limiter.Allow() {
http.Error(w, http.StatusText(http.StatusTooManyRequests)+": IP limit", http.StatusTooManyRequests)
2019-09-20 21:27:40 +00:00
return
}
// General limiter to allow throttling all messages that can make it into the mpool
if !h.limiter.Allow() {
http.Error(w, http.StatusText(http.StatusTooManyRequests)+": global limit", http.StatusTooManyRequests)
return
}
2019-09-20 21:27:40 +00:00
smsg, err := h.api.MpoolPushMessage(h.ctx, &types.Message{
Value: types.BigInt(h.sendPerRequest),
2019-09-20 21:27:40 +00:00
From: h.from,
To: to,
}, nil)
2019-09-20 21:27:40 +00:00
if err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
2019-09-20 21:27:40 +00:00
return
}
_, _ = w.Write([]byte(smsg.Cid().String()))
2019-09-20 21:27:40 +00:00
}