2019-09-20 21:27:40 +00:00
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
|
|
|
"context"
|
|
|
|
"fmt"
|
2019-11-06 15:10:27 +00:00
|
|
|
"net"
|
2019-09-20 21:27:40 +00:00
|
|
|
"net/http"
|
|
|
|
"os"
|
2019-10-29 18:28:54 +00:00
|
|
|
"strconv"
|
2019-10-17 04:11:47 +00:00
|
|
|
"time"
|
2019-09-20 21:27:40 +00:00
|
|
|
|
2019-10-13 07:33:25 +00:00
|
|
|
rice "github.com/GeertJohan/go.rice"
|
2020-02-10 19:16:36 +00:00
|
|
|
"github.com/filecoin-project/specs-actors/actors/abi"
|
2019-11-09 16:53:20 +00:00
|
|
|
"github.com/ipfs/go-cid"
|
2020-01-08 19:10:57 +00:00
|
|
|
logging "github.com/ipfs/go-log/v2"
|
2019-10-17 08:12:53 +00:00
|
|
|
peer "github.com/libp2p/go-libp2p-peer"
|
2019-09-20 21:27:40 +00:00
|
|
|
"golang.org/x/xerrors"
|
|
|
|
"gopkg.in/urfave/cli.v2"
|
|
|
|
|
2019-12-19 20:13:17 +00:00
|
|
|
"github.com/filecoin-project/go-address"
|
2019-10-18 04:47:41 +00:00
|
|
|
"github.com/filecoin-project/lotus/api"
|
|
|
|
"github.com/filecoin-project/lotus/build"
|
2019-10-17 08:12:53 +00:00
|
|
|
"github.com/filecoin-project/lotus/chain/actors"
|
2019-10-18 04:47:41 +00:00
|
|
|
"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")
|
|
|
|
|
2019-11-06 15:10:27 +00:00
|
|
|
var sendPerRequest, _ = types.ParseFIL("0.005")
|
2019-09-20 21:27:40 +00:00
|
|
|
|
|
|
|
func main() {
|
|
|
|
logging.SetLogLevel("*", "INFO")
|
|
|
|
|
|
|
|
log.Info("Starting fountain")
|
|
|
|
|
|
|
|
local := []*cli.Command{
|
|
|
|
runCmd,
|
|
|
|
}
|
|
|
|
|
|
|
|
app := &cli.App{
|
|
|
|
Name: "lotus-fountain",
|
|
|
|
Usage: "Devnet token distribution utility",
|
2019-12-11 22:00:39 +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",
|
|
|
|
},
|
|
|
|
},
|
|
|
|
Action: func(cctx *cli.Context) error {
|
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
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Info("Remote version: %s", v.Version)
|
|
|
|
|
|
|
|
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,
|
2019-10-17 04:11:47 +00:00
|
|
|
limiter: NewLimiter(LimiterConfig{
|
|
|
|
TotalRate: time.Second,
|
|
|
|
TotalBurst: 20,
|
2019-10-17 14:28:03 +00:00
|
|
|
IPRate: time.Minute,
|
2019-10-17 04:11:47 +00:00
|
|
|
IPBurst: 5,
|
2019-10-17 14:28:03 +00:00
|
|
|
WalletRate: 15 * time.Minute,
|
2019-12-11 15:23:11 +00:00
|
|
|
WalletBurst: 2,
|
2019-10-17 04:11:47 +00:00
|
|
|
}),
|
2019-11-09 16:53:20 +00:00
|
|
|
minerLimiter: NewLimiter(LimiterConfig{
|
2019-10-17 04:11:47 +00:00
|
|
|
TotalRate: time.Second,
|
|
|
|
TotalBurst: 20,
|
2019-10-17 14:28:03 +00:00
|
|
|
IPRate: 10 * time.Minute,
|
2019-11-06 15:10:27 +00:00
|
|
|
IPBurst: 2,
|
2019-10-17 14:28:03 +00:00
|
|
|
WalletRate: 1 * time.Hour,
|
2019-12-11 15:23:11 +00:00
|
|
|
WalletBurst: 2,
|
2019-10-17 04:11:47 +00:00
|
|
|
}),
|
2019-09-20 21:27:40 +00:00
|
|
|
}
|
|
|
|
|
2019-10-13 07:33:25 +00:00
|
|
|
http.Handle("/", http.FileServer(rice.MustFindBox("site").HTTPBox()))
|
2019-09-20 21:27:40 +00:00
|
|
|
http.HandleFunc("/send", h.send)
|
2019-10-17 00:43:38 +00:00
|
|
|
http.HandleFunc("/mkminer", h.mkminer)
|
2019-11-09 16:53:20 +00:00
|
|
|
http.HandleFunc("/msgwait", h.msgwait)
|
|
|
|
http.HandleFunc("/msgwaitaddr", h.msgwaitaddr)
|
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)
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
type handler struct {
|
|
|
|
ctx context.Context
|
|
|
|
api api.FullNode
|
|
|
|
|
|
|
|
from address.Address
|
2019-10-17 04:11:47 +00:00
|
|
|
|
2019-11-09 16:53:20 +00:00
|
|
|
limiter *Limiter
|
|
|
|
minerLimiter *Limiter
|
2019-09-20 21:27:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (h *handler) send(w http.ResponseWriter, r *http.Request) {
|
2019-10-31 17:24:59 +00:00
|
|
|
to, err := address.NewFromString(r.FormValue("address"))
|
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
w.Write([]byte(err.Error()))
|
2019-10-17 04:11:47 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-10-31 17:24:59 +00:00
|
|
|
// Limit based on wallet address
|
|
|
|
limiter := h.limiter.GetWalletLimiter(to.String())
|
2019-10-17 04:11:47 +00:00
|
|
|
if !limiter.Allow() {
|
2019-12-11 15:23:11 +00:00
|
|
|
http.Error(w, http.StatusText(http.StatusTooManyRequests)+": wallet limit", http.StatusTooManyRequests)
|
2019-10-17 04:11:47 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-10-31 17:24:59 +00:00
|
|
|
// Limit based on IP
|
2019-11-06 15:10:27 +00:00
|
|
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
if i := net.ParseIP(reqIP); i != nil && i.IsLoopback() {
|
|
|
|
log.Errorf("rate limiting localhost: %s", reqIP)
|
|
|
|
}
|
|
|
|
|
|
|
|
limiter = h.limiter.GetIPLimiter(reqIP)
|
2019-10-31 17:24:59 +00:00
|
|
|
if !limiter.Allow() {
|
2019-12-11 15:23:11 +00:00
|
|
|
http.Error(w, http.StatusText(http.StatusTooManyRequests)+": IP limit", http.StatusTooManyRequests)
|
2019-09-20 21:27:40 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-10-31 17:24:59 +00:00
|
|
|
// General limiter to allow throttling all messages that can make it into the mpool
|
|
|
|
if !h.limiter.Allow() {
|
2019-12-11 15:23:11 +00:00
|
|
|
http.Error(w, http.StatusText(http.StatusTooManyRequests)+": global limit", http.StatusTooManyRequests)
|
2019-10-17 04:11:47 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-09-20 21:27:40 +00:00
|
|
|
smsg, err := h.api.MpoolPushMessage(h.ctx, &types.Message{
|
2019-11-06 15:10:27 +00:00
|
|
|
Value: types.BigInt(sendPerRequest),
|
2019-09-20 21:27:40 +00:00
|
|
|
From: h.from,
|
|
|
|
To: to,
|
|
|
|
|
|
|
|
GasPrice: types.NewInt(0),
|
|
|
|
GasLimit: types.NewInt(1000),
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
w.Write([]byte(err.Error()))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
w.Write([]byte(smsg.Cid().String()))
|
|
|
|
}
|
2019-10-13 07:33:25 +00:00
|
|
|
|
2019-10-17 00:43:38 +00:00
|
|
|
func (h *handler) mkminer(w http.ResponseWriter, r *http.Request) {
|
2019-10-17 08:12:53 +00:00
|
|
|
owner, err := address.NewFromString(r.FormValue("address"))
|
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
w.Write([]byte(err.Error()))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if owner.Protocol() != address.BLS {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
w.Write([]byte("Miner address must use BLS"))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-11-09 16:53:20 +00:00
|
|
|
ssize, err := strconv.ParseInt(r.FormValue("sectorSize"), 10, 64)
|
|
|
|
if err != nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
log.Infof("%s: create actor start", owner)
|
2019-10-17 08:12:53 +00:00
|
|
|
|
|
|
|
// Limit based on wallet address
|
2019-11-09 16:53:20 +00:00
|
|
|
limiter := h.minerLimiter.GetWalletLimiter(owner.String())
|
2019-10-31 17:24:59 +00:00
|
|
|
if !limiter.Allow() {
|
2019-12-11 15:23:11 +00:00
|
|
|
http.Error(w, http.StatusText(http.StatusTooManyRequests)+": wallet limit", http.StatusTooManyRequests)
|
2019-10-31 17:24:59 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Limit based on IP
|
2019-11-09 16:53:20 +00:00
|
|
|
limiter = h.minerLimiter.GetIPLimiter(r.RemoteAddr)
|
2019-10-17 08:12:53 +00:00
|
|
|
if !limiter.Allow() {
|
2019-12-11 15:23:11 +00:00
|
|
|
http.Error(w, http.StatusText(http.StatusTooManyRequests)+": IP limit", http.StatusTooManyRequests)
|
2019-10-17 08:12:53 +00:00
|
|
|
return
|
|
|
|
}
|
2019-10-31 17:24:59 +00:00
|
|
|
|
|
|
|
// General limiter owner allow throttling all messages that can make it into the mpool
|
2019-11-09 16:53:20 +00:00
|
|
|
if !h.minerLimiter.Allow() {
|
2019-12-11 15:23:11 +00:00
|
|
|
http.Error(w, http.StatusText(http.StatusTooManyRequests)+": global limit", http.StatusTooManyRequests)
|
2019-10-31 17:24:59 +00:00
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-10-17 08:12:53 +00:00
|
|
|
collateral, err := h.api.StatePledgeCollateral(r.Context(), nil)
|
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
w.Write([]byte(err.Error()))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
smsg, err := h.api.MpoolPushMessage(h.ctx, &types.Message{
|
2019-11-06 15:10:27 +00:00
|
|
|
Value: types.BigInt(sendPerRequest),
|
2019-10-17 08:12:53 +00:00
|
|
|
From: h.from,
|
|
|
|
To: owner,
|
|
|
|
|
|
|
|
GasPrice: types.NewInt(0),
|
|
|
|
GasLimit: types.NewInt(1000),
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
w.Write([]byte("pushfunds: " + err.Error()))
|
|
|
|
return
|
|
|
|
}
|
2019-11-09 16:53:20 +00:00
|
|
|
log.Infof("%s: push funds %s", owner, smsg.Cid())
|
2019-10-17 08:12:53 +00:00
|
|
|
|
|
|
|
params, err := actors.SerializeParams(&actors.CreateStorageMinerParams{
|
|
|
|
Owner: owner,
|
|
|
|
Worker: owner,
|
2020-02-10 19:16:36 +00:00
|
|
|
SectorSize: abi.SectorSize(ssize),
|
2019-10-17 08:12:53 +00:00
|
|
|
PeerID: peer.ID("SETME"),
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
w.Write([]byte(err.Error()))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
createStorageMinerMsg := &types.Message{
|
2019-10-29 13:34:33 +00:00
|
|
|
To: actors.StoragePowerAddress,
|
2019-10-17 08:12:53 +00:00
|
|
|
From: h.from,
|
2020-01-16 01:00:01 +00:00
|
|
|
Value: types.BigAdd(collateral, types.BigDiv(collateral, types.NewInt(100))),
|
2019-10-17 08:12:53 +00:00
|
|
|
|
|
|
|
Method: actors.SPAMethods.CreateStorageMiner,
|
|
|
|
Params: params,
|
|
|
|
|
|
|
|
GasLimit: types.NewInt(10000000),
|
|
|
|
GasPrice: types.NewInt(0),
|
|
|
|
}
|
|
|
|
|
|
|
|
signed, err := h.api.MpoolPushMessage(r.Context(), createStorageMinerMsg)
|
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
w.Write([]byte(err.Error()))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-11-09 16:53:20 +00:00
|
|
|
log.Infof("%s: create miner msg: %s", owner, signed.Cid())
|
|
|
|
|
|
|
|
http.Redirect(w, r, fmt.Sprintf("/wait.html?f=%s&m=%s&o=%s", signed.Cid(), smsg.Cid(), owner), 303)
|
|
|
|
}
|
2019-10-17 08:12:53 +00:00
|
|
|
|
2019-11-09 16:53:20 +00:00
|
|
|
func (h *handler) msgwait(w http.ResponseWriter, r *http.Request) {
|
|
|
|
c, err := cid.Parse(r.FormValue("cid"))
|
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
w.Write([]byte(err.Error()))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
mw, err := h.api.StateWaitMsg(r.Context(), c)
|
2019-10-17 08:12:53 +00:00
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
w.Write([]byte(err.Error()))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
if mw.Receipt.ExitCode != 0 {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
w.Write([]byte(xerrors.Errorf("create storage miner failed: exit code %d", mw.Receipt.ExitCode).Error()))
|
|
|
|
return
|
|
|
|
}
|
2019-11-09 16:53:20 +00:00
|
|
|
w.WriteHeader(200)
|
|
|
|
}
|
2019-10-17 08:12:53 +00:00
|
|
|
|
2019-11-09 16:53:20 +00:00
|
|
|
func (h *handler) msgwaitaddr(w http.ResponseWriter, r *http.Request) {
|
|
|
|
c, err := cid.Parse(r.FormValue("cid"))
|
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
w.Write([]byte(err.Error()))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
mw, err := h.api.StateWaitMsg(r.Context(), c)
|
2019-10-17 08:12:53 +00:00
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
w.Write([]byte(err.Error()))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2019-11-09 16:53:20 +00:00
|
|
|
if mw.Receipt.ExitCode != 0 {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
w.Write([]byte(xerrors.Errorf("create storage miner failed: exit code %d", mw.Receipt.ExitCode).Error()))
|
|
|
|
return
|
|
|
|
}
|
2019-10-17 08:12:53 +00:00
|
|
|
w.WriteHeader(200)
|
2019-11-09 16:53:20 +00:00
|
|
|
|
|
|
|
addr, err := address.NewFromBytes(mw.Receipt.Return)
|
|
|
|
if err != nil {
|
|
|
|
w.WriteHeader(400)
|
|
|
|
w.Write([]byte(err.Error()))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
fmt.Fprintf(w, "{\"addr\": \"%s\"}", addr)
|
2019-10-13 07:33:25 +00:00
|
|
|
}
|