commitments.go

// (c) Cartesi and individual authors (see AUTHORS)
// SPDX-License-Identifier: Apache-2.0 (see LICENSE)

package commitments

import (
	"encoding/json"
	"fmt"

	"github.com/cartesi/rollups-node/internal/config"
	"github.com/cartesi/rollups-node/internal/jsonrpc"
	"github.com/cartesi/rollups-node/internal/read"

	"github.com/spf13/cobra"
)

var Cmd = &cobra.Command{
	Use:     "commitments <application> [epoch index] [tournament address] [commitment]",
	Short:   "Reads commitments",
	Example: examples,
	Args:    cobra.RangeArgs(1, 4), // nolint: mnd
	Run:     run,
	Long: `
Supported Environment Variables:
  CARTESI_DATABASE_CONNECTION                    Database connection string`,
}

const examples = `# Read specific commitment:
cartesi-rollups-cli read commitments echo-dapp 10 0x0073a8637d98649717bdc02ecb439c80aa8a10d0 0xdb99c9cdb2e2070a4e4e633c2e6874648dfe3971d14da843465b3d950df3dd19

# Read all commitments:
cartesi-rollups-cli read commitments echo-dapp

# Read all commitments with filter:
cartesi-rollups-cli read commitments echo-dapp --epoch-index 10 --tournament-address 0x0073a8637d98649717bdc02ecb439c80aa8a10d0

# Read all commitments with pagination:
cartesi-rollups-cli read commitments echo-dapp --limit 10 --offset 10
`

var (
	epochIndex        string
	tournamentAddress string
	limit             uint64
	offset            uint64
)

func init() {
	Cmd.Flags().StringVar(&epochIndex, "epoch-index", "",
		"Filter commitments by epoch index (decimal or hex encoded)")
	Cmd.Flags().StringVar(&tournamentAddress, "tournament-address", "",
		"Filter commitments by tournament address (hex encoded)")
	Cmd.Flags().Uint64Var(&limit, "limit", 50,
		"Maximum number of results to return")
	Cmd.Flags().Uint64Var(&offset, "offset", 0,
		"Starting point for the list of results")

	origHelpFunc := Cmd.HelpFunc()
	Cmd.SetHelpFunc(func(command *cobra.Command, strings []string) {
		command.Flags().Lookup("verbose").Hidden = false
		command.Flags().Lookup("database-connection").Hidden = false
		origHelpFunc(command, strings)
	})

	Cmd.PreRunE = func(cmd *cobra.Command, args []string) error {
		if limit > jsonrpc.LIST_ITEM_LIMIT {
			return fmt.Errorf("limit cannot exceed %d", jsonrpc.LIST_ITEM_LIMIT)
		} else if limit == 0 {
			limit = jsonrpc.LIST_ITEM_LIMIT
		}
		return nil
	}
}

func run(cmd *cobra.Command, args []string) {
	ctx := cmd.Context()

	var (
		readServ read.ReadService
		err      error
	)

	addr := cmd.Flags().Lookup("jsonrpc-api-address").Value.String()
	if addr != "" {
		readServ, err = read.NewJsonrpcReadService(ctx, addr)
	} else {
		dsn, err := config.GetDatabaseConnection()
		cobra.CheckErr(err)

		readServ, err = read.NewRepositoryReadService(ctx, dsn.String())
	}
	cobra.CheckErr(err)
	defer readServ.Close()

	var result json.RawMessage
	if len(args) >= 4 {
		var params jsonrpc.GetCommitmentParams
		params.Application = args[0]
		// Convert from decimal to hexadecimal
		epochIndexNumeric, err := config.ToUint64FromDecimalOrHexString(args[1])
		if err != nil {
			cobra.CheckErr(err)
		}
		params.EpochIndex = fmt.Sprintf("0x%02x", epochIndexNumeric)
		params.TournamentAddress = args[2]
		params.Commitment = args[3]

		result, err = readServ.GetCommitment(ctx, params)
	} else if len(args) >= 1 {
		var params jsonrpc.ListCommitmentsParams
		params.Application = args[0]

		// Add epoch index filter if provided
		if cmd.Flags().Changed("epoch-index") {
			// Convert from decimal to hexadecimal
			epochIndexNumeric, err := config.ToUint64FromDecimalOrHexString(epochIndex)
			if err != nil {
				cobra.CheckErr(err)
			}
			epochIndexConverted := fmt.Sprintf("0x%02x", epochIndexNumeric)
			params.EpochIndex = &epochIndexConverted
		}

		// Add tournament address filter if provided
		if cmd.Flags().Changed("tournament-address") {
			params.TournamentAddress = &tournamentAddress
		}
		params.Limit = limit
		params.Offset = offset

		result, err = readServ.ListCommitments(ctx, params)
	}
	cobra.CheckErr(err)

	formatted, err := json.MarshalIndent(result, "", "    ")
	cobra.CheckErr(err)

	fmt.Println(string(formatted))
}