feat(cli): add PRT consensus to deploy application

Author: mpolitzer

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

@@ -221,6 +221,15 @@ func runDeployApplication(cmd *cobra.Command, args []string) {
 		application.EpochLength = res.Deployment.EpochLength
 		application.DataAvailability = res.Deployment.DataAvailability
 		application.IInputBoxBlock = res.Deployment.IInputBoxBlock
+
+	case *ethutil.PRTApplicationDeploymentResult:
+		application.IApplicationAddress = res.ApplicationResult.ApplicationAddress
+		application.IConsensusAddress = res.ApplicationResult.Deployment.Consensus
+		application.IInputBoxAddress = res.ApplicationResult.Deployment.InputBoxAddress
+		application.TemplateHash = res.ApplicationResult.Deployment.TemplateHash
+		application.EpochLength = res.ApplicationResult.Deployment.EpochLength
+		application.DataAvailability = res.ApplicationResult.Deployment.DataAvailability
+		application.IInputBoxBlock = res.ApplicationResult.Deployment.IInputBoxBlock
 	default:
 		panic("unimplemented deployment type\n")
 	}
@@ -447,11 +456,11 @@ func buildPrtApplicationDeployment(
 	client *ethclient.Client,
 	txOpts *bind.TransactOpts,
 ) (
-	*ethutil.PRTDeployment,
+	*ethutil.PRTApplicationDeployment,
 	error,
 ) {
 	var err error
-	request := &ethutil.PRTDeployment{}
+	request := &ethutil.PRTApplicationDeployment{}
 	if !cmd.Flags().Changed("prt-factory") {
 		request.FactoryAddress, err = config.GetContractsPrtFactoryAddress()
 	} else {
@@ -461,7 +470,7 @@ func buildPrtApplicationDeployment(
 		return nil, fmt.Errorf("error on parameter factory: %w", err)
 	}
 
-	request.App, err = buildApplicationOnlyDeploymentWithoutConsensus(cmd, args, client, txOpts)
+	request.Application, err = buildApplicationOnlyDeploymentWithoutConsensus(cmd, args, client, txOpts)
 	if err != nil {
 		return nil, fmt.Errorf("error on application: %w", err)
 	}

pkg/ethutil/prt.go

@@ -4,6 +4,7 @@ package ethutil
 
 import (
 	"context"
+	"encoding/hex"
 	"fmt"
 	"math/big"
 
@@ -15,25 +16,41 @@ import (
 	"github.com/ethereum/go-ethereum/ethclient"
 )
 
-type PRTDeployment struct {
-	App            *ApplicationDeployment
+type PRTApplicationDeployment struct {
 	FactoryAddress common.Address
+	TemplateHash   common.Hash
+	Salt           SaltBytes
+
+	Application *ApplicationDeployment
 }
 
-type PRTDeploymentResult struct {
+type PRTApplicationDeploymentResult struct {
+	Deployment        *PRTApplicationDeployment
+	ApplicationResult *ApplicationDeploymentResult
 }
 
-func (me *PRTDeployment) String() string {
+func (me *PRTApplicationDeployment) String() string {
 	result := ""
-	result += me.App.String()
-	if me.App.Verbose {
+	result += fmt.Sprintf("PRT application deployment:\n")
+	result += fmt.Sprintf("\tapplication owner:     %v\n", me.Application.OwnerAddress)
+	if me.Application.Verbose {
 		result += fmt.Sprintf("\tPRT factory address:   %v\n", me.FactoryAddress)
-		result += fmt.Sprintf("\tPRT consensus address: %v\n", me.App.Consensus)
+		result += fmt.Sprintf("\tAPP factory address:   %v\n", me.Application.FactoryAddress)
+		result += fmt.Sprintf("\ttemplate hash:         %v\n", me.Application.TemplateHash)
+		result += fmt.Sprintf("\tdata availability:     0x%v\n", hex.EncodeToString(me.Application.DataAvailability))
+		result += fmt.Sprintf("\tsalt:                  %v\n", me.Application.Salt)
 	}
 	return result
 }
 
-func (me *PRTDeployment) deployPRT(
+func (me *PRTApplicationDeploymentResult) String() string {
+	result := ""
+	result += fmt.Sprintf("\tapplication address:   %v\n", me.ApplicationResult.ApplicationAddress)
+	result += fmt.Sprintf("\tconsensus address:     %v\n", me.ApplicationResult.Deployment.Consensus)
+	return result
+}
+
+func (me *PRTApplicationDeployment) deployPRT(
 	ctx context.Context,
 	client *ethclient.Client,
 	txOpts *bind.TransactOpts,
@@ -45,7 +62,7 @@ func (me *PRTDeployment) deployPRT(
 	if err != nil {
 		return zero, fmt.Errorf("failed to instantiate contract: %v", err)
 	}
-	tx, err := factory.NewDaveConsensus(txOpts, applicationAddress, me.App.TemplateHash, me.App.Salt)
+	tx, err := factory.NewDaveConsensus(txOpts, applicationAddress, me.TemplateHash, me.Salt)
 	if err != nil {
 		return zero, fmt.Errorf("transaction failed: %v", err)
 	}
@@ -72,19 +89,29 @@ func (me *PRTDeployment) deployPRT(
 }
 
 // Do the consensus/application dance based on: https://github.com/cartesi/dave/blob/v1.0.0/cartesi-rollups/contracts/cannonfile.prod-instance.toml
-func (me *PRTDeployment) Deploy(
+func (me *PRTApplicationDeployment) Deploy(
 	ctx context.Context,
 	client *ethclient.Client,
 	txOpts *bind.TransactOpts,
 ) (common.Address, IApplicationDeploymentResult, error) {
 	zero := common.Address{}
+	result := &PRTApplicationDeploymentResult{}
+	result.Deployment = me
 
-	applicationAddress, result, err := me.App.Deploy(ctx, client, txOpts)
+	var err error
+	applicationAddress, appResult, err := me.Application.Deploy(ctx, client, txOpts)
 	if err != nil {
 		return zero, nil, err
 	}
 
-	me.App.Consensus, err = me.deployPRT(ctx, client, txOpts, applicationAddress)
+	switch appRes := appResult.(type) {
+	case *ApplicationDeploymentResult:
+		result.ApplicationResult = appRes
+	default:
+		panic("Application deployment returned an impossible type.")
+	}
+
+	consensus, err := me.deployPRT(ctx, client, txOpts, applicationAddress)
 	if err != nil {
 		return zero, nil, fmt.Errorf("failed to deploy PRT contract: %w", err)
 	}
@@ -96,7 +123,7 @@ func (me *PRTDeployment) Deploy(
 
 	_, err = sendTransaction(ctx, client, txOpts, big.NewInt(0), GasLimit,
 		func(txOpts *bind.TransactOpts) (*types.Transaction, error) {
-			return application.MigrateToOutputsMerkleRootValidator(txOpts, me.App.Consensus)
+			return application.MigrateToOutputsMerkleRootValidator(txOpts, consensus)
 		},
 	)
 	if err != nil {
@@ -112,9 +139,10 @@ func (me *PRTDeployment) Deploy(
 		return zero, nil, fmt.Errorf("failed to create a self hosted application: execution reverted")
 	}
 
+	result.ApplicationResult.Deployment.Consensus = consensus
 	return applicationAddress, result, nil
 }
 
-func (me *PRTDeployment) GetFactoryAddress() common.Address {
+func (me *PRTApplicationDeployment) GetFactoryAddress() common.Address {
 	return me.FactoryAddress
 }