fix(cli): improve "deploy application" reporting

Author: mpolitzer

cmd/cartesi-rollups-cli/root/deploy/application.go

@@ -72,40 +72,50 @@ func runDeployAuthority(cmd *cobra.Command, args []string) {
 	txOpts, err := auth.GetTransactOpts(chainId)
 	cobra.CheckErr(err)
 
-	authority, err := buildAuthorityDeployment(cmd, txOpts)
+	deployment, err := buildAuthorityDeployment(cmd, txOpts)
 	cobra.CheckErr(err)
 
-	if !asJson {
-		fmt.Printf("Deploying authority...")
+	if verboseParam {
+		fmt.Fprint(os.Stderr, deployment)
+		fmt.Fprintln(os.Stderr, "\twallet address:       ", txOpts.From)
+
+	}
+
+	// factory check
+	if verboseParam {
+		fmt.Fprint(os.Stderr, "checking factory address...")
 	}
-	authority.Address, err = authority.Deploy(ctx, client, txOpts)
+
+	factoryAddress := deployment.FactoryAddress
+	data, err := client.CodeAt(ctx, factoryAddress, nil)
 	cobra.CheckErr(err)
 
-	if err != nil {
-		if asJson {
-			data := struct {
-				Code    int
-				Message string
-			}{
-				Code:    1,
-				Message: err.Error(),
-			}
-			report, err := json.MarshalIndent(&data, "", "  ")
-			cobra.CheckErr(err)
-			fmt.Println(string(report))
-		} else {
-			fmt.Fprintf(os.Stderr, "%v.\n", err)
-		}
-		os.Exit(1)
-	} else {
-		if asJson {
-			report, err := json.MarshalIndent(&authority, "", "  ")
-			cobra.CheckErr(err) // deployed, but fail to print
-			fmt.Println(string(report))
-		} else {
-			fmt.Printf("success\n\n")
-			fmt.Println("consensus address: ", authority.Address)
-		}
+	if len(data) == 0 {
+		cobra.CheckErr(fmt.Errorf("No code at the factory address: %v", factoryAddress))
+	}
+	if verboseParam {
+		fmt.Fprint(os.Stderr, "success\n")
+	}
+
+	// deploy
+	if verboseParam || !asJsonParam {
+		fmt.Fprintf(os.Stderr, "deploying authority...")
+	}
+	deployment.Address, err = deployment.Deploy(ctx, client, txOpts)
+	cobra.CheckErr(err)
+
+	// report
+	if verboseParam || !asJsonParam {
+		fmt.Fprintf(os.Stderr, "success\n")
+		fmt.Fprintln(os.Stderr, "\tconsensus address:    ", deployment.Address)
+		fmt.Fprintln(os.Stderr, "\tepoch length:         ", deployment.EpochLength)
+	}
+
+	if asJsonParam {
+		report, err := json.MarshalIndent(&deployment, "", "  ")
+		cobra.CheckErr(err) // deployed, but fail to print
+
+		fmt.Println(string(report))
 	}
 }
 
@@ -120,27 +130,28 @@ func buildAuthorityDeployment(cmd *cobra.Command, txOpts *bind.TransactOpts) (*e
 		authorityFactoryAddress, err = parseHexAddress(authorityFactoryAddressParam)
 	}
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("error on parameter authority-factory: %w", err)
 	}
 
 	if !cmd.Flags().Changed("authority-owner") {
 		authorityOwnerAddress = txOpts.From
 	} else {
 		authorityOwnerAddress, err = parseHexAddress(authorityOwnerAddressParam)
-		if err != nil {
-			return nil, err
-		}
+	}
+	if err != nil {
+		return nil, fmt.Errorf("error on parameter authority-owner: %w", err)
 	}
 
 	salt, err := ethutil.ParseSalt(saltParam)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("error on parameter salt: %w", err)
 	}
 
 	return &ethutil.AuthorityDeployment{
 		FactoryAddress: authorityFactoryAddress,
 		OwnerAddress:   authorityOwnerAddress,
 		EpochLength:    epochLengthParam,
 		Salt:           salt,
+		Verbose:        verboseParam,
 	}, nil
 }

cmd/cartesi-rollups-cli/root/deploy/authority.go

@@ -13,8 +13,8 @@ import (
 var (
 	epochLengthParam uint64
 	saltParam        string
-	asJson           bool
-	verbose          bool
+	asJsonParam      bool
+	verboseParam     bool
 )
 
 var Cmd = &cobra.Command{
@@ -30,10 +30,10 @@ func init() {
 	Cmd.PersistentFlags().StringVar(&saltParam, "salt", "0000000000000000000000000000000000000000000000000000000000000000",
 		"Salt value for contract deployment")
 	Cmd.PersistentFlags().MarkHidden("salt")
-	Cmd.PersistentFlags().BoolVarP(&asJson, "json", "", false,
+	Cmd.PersistentFlags().BoolVarP(&asJsonParam, "json", "", false,
 		"Print results as JSON")
 	Cmd.PersistentFlags().MarkHidden("json")
-	Cmd.PersistentFlags().BoolVarP(&verbose, "verbose", "", false,
+	Cmd.PersistentFlags().BoolVarP(&verboseParam, "verbose", "", false,
 		"Print extra information")
 	Cmd.PersistentFlags().MarkHidden("verbose")
 

cmd/cartesi-rollups-cli/root/deploy/deploy.go

@@ -65,7 +65,7 @@ func (r *PostgresRepository) CreateApplication(
 	var newID int64
 	err = tx.QueryRow(ctx, sqlStr, args...).Scan(&newID)
 	if err != nil {
-		return 0, errors.Join(err, tx.Rollback(ctx))
+		return 0, errors.Join(fmt.Errorf("unable to create database application: %w", err), tx.Rollback(ctx))
 	}
 
 	sqlStr, args = table.ExecutionParameters.

cmd/cartesi-rollups-cli/root/deploy/selfhosted.go

@@ -50,11 +50,15 @@ func CreateAnvilSnapshotAndDeployApp(ctx context.Context, client *ethclient.Clie
 	if err != nil {
 		return zero, nil, fmt.Errorf("failed retrieve self hosted application factory address: %w", err)
 	}
-	deployment := &SelfhostedDeployment{
-		FactoryAddress: selfHostedApplicationFactoryAddress,
-		OwnerAddress:   txOpts.From,
-		TemplateHash:   templateHash,
-		EpochLength:    10,
+
+	deployment := &SelfhostedApplicationDeployment{
+		FactoryAddress:          selfHostedApplicationFactoryAddress,
+		ApplicationOwnerAddress: txOpts.From,
+		AuthorityOwnerAddress:   txOpts.From,
+		TemplateHash:            templateHash,
+		DataAvailability:        dataAvailability,
+		EpochLength:             10,
+		Salt:                    [32]byte{},
 	}
 	applicationAddress, _, err := deployment.Deploy(ctx, client, txOpts)
 

internal/repository/postgres/application.go

@@ -4,66 +4,89 @@ package ethutil
 
 import (
 	"context"
+	"encoding/hex"
 	"fmt"
 
-	"github.com/cartesi/rollups-node/internal/model"
 	"github.com/cartesi/rollups-node/pkg/contracts/iapplicationfactory"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
 )
 
-// NOTE: json formatting breaks if we don't use a separate type, don't know why
+type IApplicationDeployment interface {
+	Deploy(ctx context.Context, client *ethclient.Client, txOpts *bind.TransactOpts) (common.Address, IApplicationDeploymentResult, error)
+	GetFactoryAddress() common.Address
+}
+type IApplicationDeploymentResult interface{}
+
 type ApplicationDeployment struct {
-	model.Application `json:"application"`
-	FactoryAddress    common.Address        `json:"factory"`
-	OwnerAddress      common.Address        `json:"owner"`
-	Salt              SaltBytes             `json:"salt"`
-	WithAuthority     *AuthorityDeployment  `json:"authority,omitempty"`
-	WithSelfHosted    *SelfhostedDeployment `json:"selfhosted,omitempty"`
+	FactoryAddress   common.Address `json:"factory"`
+	Consensus        common.Address `json:"consensus"`
+	OwnerAddress     common.Address `json:"owner"`
+	DataAvailability []byte         `json:"-"`
+	TemplateHash     common.Hash    `json:"template_hash"`
+	Salt             SaltBytes      `json:"salt"`
+
+	// needed by model.Application
+	InputBoxAddress common.Address `json:"inputbox_address"`
+	IInputBoxBlock  uint64         `json:"inputbox_block"`
+	EpochLength     uint64         `json:"epoch_length"`
+
+	Verbose bool
 }
 
-// function does one of 3 things:
-// - withSelfHosted != nil => application + authority (together via SelfHosted contract)
-// - withAuthority != nil =>  application + authority (as two separate deployments)
-// - withSelfHosted == nil && withAuthority == nil => application only
-func (me *ApplicationDeployment) Deploy(ctx context.Context, client *ethclient.Client, txOpts *bind.TransactOpts) (common.Address, error) {
-	var err error
-	zero := common.Address{}
-	var applicationAddress common.Address
+type ApplicationDeploymentResult struct {
+	Deployment *ApplicationDeployment `json:"deployment"`
 
-	if me.WithSelfHosted != nil {
-		applicationAddress, me.IConsensusAddress, err = me.WithSelfHosted.Deploy(ctx, client, txOpts)
-		if err != nil {
-			return zero, err
-		}
-		return applicationAddress, nil
-	}
+	ApplicationAddress common.Address `json:"address"`
+}
 
-	if me.WithAuthority != nil {
-		me.IConsensusAddress, err = me.WithAuthority.Deploy(ctx, client, txOpts)
-		if err != nil {
-			return zero, err
-		}
+func (me *ApplicationDeployment) String() string {
+	result := ""
+	result += fmt.Sprintf("application deployment:\n")
+	result += fmt.Sprintf("\tapplication owner:     %v\n", me.OwnerAddress)
+	result += fmt.Sprintf("\tconsensus address:     %v\n", me.Consensus)
+	if me.Verbose {
+		result += fmt.Sprintf("\tfactory address:       %v\n", me.FactoryAddress)
+		result += fmt.Sprintf("\ttemplate hash:         %v\n", me.TemplateHash)
+		result += fmt.Sprintf("\tdata availability:     0x%v\n", hex.EncodeToString(me.DataAvailability))
+		result += fmt.Sprintf("\tsalt:                  %v\n", me.Salt)
+		result += fmt.Sprintf("\tepoch length:          %v\n", me.EpochLength)
 	}
+	return result
+}
+
+func (me *ApplicationDeploymentResult) String() string {
+	result := ""
+	result += fmt.Sprintf("\tapplication address:   %v\n", me.ApplicationAddress)
+	return result
+}
 
+func (me *ApplicationDeployment) Deploy(
+	ctx context.Context,
+	client *ethclient.Client,
+	txOpts *bind.TransactOpts,
+) (common.Address, IApplicationDeploymentResult, error) {
+	zero := common.Address{}
+	result := &ApplicationDeploymentResult{}
+	result.Deployment = me
 	factory, err := iapplicationfactory.NewIApplicationFactory(me.FactoryAddress, client)
 	if err != nil {
-		return zero, fmt.Errorf("failed to instantiate contract: %v", err)
+		return zero, nil, fmt.Errorf("failed to instantiate contract: %v", err)
 	}
 
-	tx, err := factory.NewApplication(txOpts, me.IConsensusAddress, me.OwnerAddress, me.TemplateHash, me.DataAvailability, me.Salt)
+	tx, err := factory.NewApplication(txOpts, me.Consensus, me.OwnerAddress, me.TemplateHash, me.DataAvailability, me.Salt)
 	if err != nil {
-		return zero, fmt.Errorf("transaction failed: %v", err)
+		return zero, nil, fmt.Errorf("transaction failed: %v", err)
 	}
 
 	receipt, err := bind.WaitMined(ctx, client, tx)
 	if err != nil {
-		return zero, fmt.Errorf("failed to wait for transaction mining: %v", err)
+		return zero, nil, fmt.Errorf("failed to wait for transaction mining: %v", err)
 	}
 
 	if receipt.Status != 1 {
-		return zero, fmt.Errorf("transaction failed")
+		return zero, nil, fmt.Errorf("transaction failed")
 	}
 
 	// Look for the specific event in the receipt logs
@@ -73,7 +96,12 @@ func (me *ApplicationDeployment) Deploy(ctx context.Context, client *ethclient.C
 		if err != nil {
 			continue // Skip logs that don't match
 		}
-		return event.AppContract, nil
+		result.ApplicationAddress = event.AppContract
+		return result.ApplicationAddress, result, nil
 	}
-	return zero, fmt.Errorf("failed to find ApplicationCreated event in receipt logs")
+	return zero, nil, fmt.Errorf("failed to find ApplicationCreated event in receipt logs")
+}
+
+func (me *ApplicationDeployment) GetFactoryAddress() common.Address {
+	return me.FactoryAddress
 }

pkg/ethutil/anvil.go

@@ -19,9 +19,26 @@ type AuthorityDeployment struct {
 	OwnerAddress   common.Address `json:"owner"`
 	EpochLength    uint64         `json:"epoch_length"`
 	Salt           SaltBytes      `json:"salt"`
+	Verbose        bool           `json:"-"`
 }
 
-func (me AuthorityDeployment) Deploy(ctx context.Context, client *ethclient.Client, txOpts *bind.TransactOpts) (common.Address, error) {
+func (me *AuthorityDeployment) String() string {
+	result := ""
+	result += fmt.Sprintf("authority deployment:\n")
+	result += fmt.Sprintf("\tauthority owner:       %v\n", me.OwnerAddress)
+	if me.Verbose {
+		result += fmt.Sprintf("\tfactory address:       %v\n", me.FactoryAddress)
+		result += fmt.Sprintf("\tsalt:                  %v\n", me.Salt)
+		result += fmt.Sprintf("\tepoch length:          %v\n", me.EpochLength)
+	}
+	return result
+}
+
+func (me AuthorityDeployment) Deploy(
+	ctx context.Context,
+	client *ethclient.Client,
+	txOpts *bind.TransactOpts,
+) (common.Address, error) {
 	contract, err := iauthorityfactory.NewIAuthorityFactory(me.FactoryAddress, client)
 	if err != nil {
 		return common.Address{}, fmt.Errorf("failed to instantiate contract: %v", err)