synapsecns/sanguine

package cmd

// TODO update this to match new commands + migrate flags to config.
import (
    "github.com/synapsecns/sanguine/core/metrics"
    "github.com/synapsecns/sanguine/services/scribe/backend"
    "github.com/synapsecns/sanguine/services/scribe/service"
    // used to embed markdown.
    _ "embed"
    "fmt"

    markdown "github.com/MichaelMure/go-term-markdown"
    "github.com/hashicorp/consul/sdk/freeport"
    "github.com/jftuga/termsize"
    "github.com/synapsecns/sanguine/core"
    "github.com/synapsecns/sanguine/services/scribe/api"
    "github.com/synapsecns/sanguine/services/scribe/config"
    "github.com/synapsecns/sanguine/services/scribe/db"
    "github.com/urfave/cli/v2"
)

//go:embed cmd.md
var help string

// MaxConfirmations is the maximum number of confirmations.
var MaxConfirmations = 3

// infoCommand gets info about using the scribe service.
var infoCommand = &cli.Command{
    Name:        "info",
    Description: "learn how to use scribe cli",
    Action: func(c *cli.Context) error {
        fmt.Println(string(markdown.Render(help, termsize.Width(), 6)))
        return nil
    },
}

var configFlag = &cli.StringFlag{
    Name:      "config",
    Usage:     "--config /Users/synapsecns/config.yaml",
    TakesFile: true,
    Required:  true,
}

var portFlag = &cli.UintFlag{
    Name:  "port",
    Usage: "--port 5121",
    Value: 0,
}

var dbFlag = &cli.StringFlag{
    Name:     "db",
    Usage:    "--db <sqlite> or <mysql>",
    Value:    "sqlite",
    Required: true,
}

var pathFlag = &cli.StringFlag{
    Name:     "path",
    Usage:    "--path <path/to/database> or <database url>",
    Value:    "",
    Required: true,
}

func createScribeParameters(c *cli.Context) (eventDB db.EventDB, clients map[uint32][]backend.ScribeBackend, scribeConfig config.Config, err error) {
    scribeConfig, err = config.DecodeConfig(core.ExpandOrReturnPath(c.String(configFlag.Name)))
    if err != nil {
        return nil, nil, scribeConfig, fmt.Errorf("could not decode config: %w", err)
    }

    eventDB, err = api.InitDB(c.Context, c.String(dbFlag.Name), c.String(pathFlag.Name), metrics.Get(), c.Bool(skipMigrationFlag.Name))
    if err != nil {
        return nil, nil, scribeConfig, fmt.Errorf("could not initialize database: %w", err)
    }

    clients = make(map[uint32][]backend.ScribeBackend)
    for _, client := range scribeConfig.Chains {
        for confNum := 1; confNum <= MaxConfirmations; confNum++ {
            backendClient, err := backend.DialBackend(c.Context, fmt.Sprintf("%s/%d/rpc/%d", scribeConfig.RPCURL, confNum, client.ChainID), metrics.Get())
            if err != nil {
                return nil, nil, scribeConfig, fmt.Errorf("could not start client for %s", fmt.Sprintf("%s/1/rpc/%d", scribeConfig.RPCURL, client.ChainID))
            }
            clients[client.ChainID] = append(clients[client.ChainID], backendClient)
        }
    }

    return eventDB, clients, scribeConfig, nil
}

var scribeCommand = &cli.Command{
    // TODO: rename this command to indexer
    Name:        "scribe",
    Description: "scribe runs the scribe, livefilling across all specified chains",
    Flags:       []cli.Flag{configFlag, dbFlag, pathFlag},
    Action: func(c *cli.Context) error {
        db, clients, decodeConfig, err := createScribeParameters(c)
        if err != nil {
            return err
        }
        scribe, err := service.NewScribe(db, clients, decodeConfig, metrics.Get())
        if err != nil {
            return fmt.Errorf("could not create scribe: %w", err)
        }
        err = scribe.Start(c.Context)
        if err != nil {
            return fmt.Errorf("could not start scribe: %w", err)
        }
        return nil
    },
}

var serverCommand = &cli.Command{
    Name:        "server",
    Description: "starts a graphql server",
    Flags:       []cli.Flag{portFlag, dbFlag, pathFlag, omniRPCFlag, skipMigrationServerFlag},
    Action: func(c *cli.Context) error {
        err := api.Start(c.Context, api.Config{
            Port:           uint16(c.Uint(portFlag.Name)),
            Database:       c.String(dbFlag.Name),
            Path:           c.String(pathFlag.Name),
            OmniRPCURL:     c.String(omniRPCFlag.Name),
            SkipMigrations: c.Bool(skipMigrationServerFlag.Name),
        }, metrics.Get())
        if err != nil {
            return fmt.Errorf("could not start server: %w", err)
        }

        return nil
    },
}

var omniRPCFlag = &cli.StringFlag{
    Name:     "omnirpc",
    Usage:    "--omnirpc https://omnirpc.url",
    Required: true,
}

var skipMigrationFlag = &cli.BoolFlag{
    Name:  "skip-migrations",
    Usage: "--skip-migrations",
    Value: false,
}

var skipMigrationServerFlag = &cli.BoolFlag{
    Name:     skipMigrationFlag.Name,
    Usage:    skipMigrationFlag.Usage,
    Required: skipMigrationFlag.Required,
    Value:    true,
}

var deploymentsPath = &cli.StringFlag{
    Name:     "deployments-dir",
    Usage:    "--deployments-dir /path/to/contracts/deployments",
    Required: true,
}

var confirmationsFlag = &cli.UintFlag{
    Name:  "confirmations",
    Value: 50,
}

var outputPathFlag = &cli.StringFlag{
    Name:      "output-path",
    TakesFile: true,
}

var skippedChainIdsFlag = &cli.IntSliceFlag{
    Name:  "skipped-chains",
    Usage: "--skipped-chains 1,2,3",
    // skip common testnets by default
    Value: cli.NewIntSlice(5, 335, 43113, 1666700000),
}

var generateCommand = &cli.Command{
    Name:        "generate",
    Description: "generates a config from a hardhat deployment folder",
    Flags: []cli.Flag{
        omniRPCFlag,
        deploymentsPath,
        confirmationsFlag,
        skippedChainIdsFlag,
        outputPathFlag,
    },
    Action: func(c *cli.Context) error {
        //nolint: wrapcheck
        return config.GenerateConfig(c.Context, c.String(omniRPCFlag.Name), core.ExpandOrReturnPath(c.String(deploymentsPath.Name)),
            core.ExpandOrReturnPath(c.String(outputPathFlag.Name)), c.IntSlice(skippedChainIdsFlag.Name), config.DefaultClientGenerator)
    },
}

func init() {
    ports, err := freeport.Take(1)
    if len(ports) > 0 && err != nil {
        portFlag.Value = uint(ports[0])
    }
}