feat(cli): add PRT consensus to deploy application

Author: mpolitzer

Makefile

@@ -97,6 +97,7 @@ env:
 	@echo export CARTESI_CONTRACTS_AUTHORITY_FACTORY_ADDRESS="0xC7003566dD09Aa0fC0Ce201aC2769aFAe3BF0051"
 	@echo export CARTESI_CONTRACTS_APPLICATION_FACTORY_ADDRESS="0xc7006f70875BaDe89032001262A846D3Ee160051"
 	@echo export CARTESI_CONTRACTS_SELF_HOSTED_APPLICATION_FACTORY_ADDRESS="0xc700285Ab555eeB5201BC00CFD4b2CC8DED90051"
+	@echo export CARTESI_CONTRACTS_PRT_FACTORY_ADDRESS="0x6e362c9458fE812D4aA796651C64D02C87AbD1cB"
 	@echo export CARTESI_AUTH_MNEMONIC=\"test test test test test test test test test test test junk\"
 	@echo export CARTESI_DATABASE_CONNECTION="postgres://postgres:password@localhost:5432/rollupsdb?sslmode=disable"
 	@echo export CARTESI_SNAPSHOTS_DIR="snapshots"

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

@@ -32,6 +32,8 @@ var (
 	applicationTemplateHashParam     string
 	factoryAddressParam              string
 	executionParametersFileParam     string
+	prtFactoryAddressParam           string
+	deploymentTypePRT                bool
 )
 
 var applicationCmd = &cobra.Command{
@@ -52,7 +54,8 @@ Supported Environment Variables:
   CARTESI_BLOCKCHAIN_HTTP_ENDPOINT                           Blockchain HTTP endpoint
   CARTESI_CONTRACTS_INPUT_BOX_ADDRESS                        Input Box contract address
   CARTESI_CONTRACTS_APPLICATION_FACTORY_ADDRESS              Application Factory address
-  CARTESI_CONTRACTS_SELF_HOSTED_APPLICATION_FACTORY_ADDRESS  Self Hosted Application Factory address`,
+  CARTESI_CONTRACTS_SELF_HOSTED_APPLICATION_FACTORY_ADDRESS  Self Hosted Application Factory address
+  CARTESI_CONTRACTS_PRT_FACTORY_ADDRESS                      PRT Factory address`,
 }
 
 const applicationExamples = `
@@ -62,20 +65,25 @@ const applicationExamples = `
 # deploy an application contract using an existing consensus, then register the application
  - cli deploy application echo-dapp applications/echo-dapp/ --consensus=0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
 
+# deploy an application contract with a PRT consensus, then register the application
+ - cli deploy application echo-dapp applications/echo-dapp/ --prt
+
 # deploy but don't register into the database
  - cli deploy application echo-dapp applications/echo-dapp/ --register=false
 
 # deploy and register into the database, but disabled
  - cli deploy application echo-dapp applications/echo-dapp/ --enable=false
 
-# deploy an application without a machine template path (both application-name and template-path may be ommited in this case)
+# deploy an application without a machine template path (both application-name and template-path may be omitted in this case)
  - cli deploy application --template-hash=0x0000000000000000000000000000000000000000000000000000000000000000 --register=false`
 
 func init() {
 	applicationCmd.Flags().StringVarP(&applicationConsensusAddressParam, "consensus", "c", "",
 		"Consensus address. A new authority consensus will be created if this field is left empty.")
 	applicationCmd.Flags().StringVarP(&factoryAddressParam, "factory", "f", "",
 		"Application factory address. Default value is retrieved from configuration.")
+	applicationCmd.Flags().StringVarP(&prtFactoryAddressParam, "prt-factory", "", "",
+		"PRT Application factory address. Default value is retrieved from configuration.")
 	applicationCmd.Flags().StringVarP(&applicationOwnerAddressParam, "application-owner", "o", "",
 		"Application owner address. If not defined, it will be derived from the auth method.")
 	applicationCmd.Flags().StringVarP(&applicationDataAvailabilityParam, "data-availability", "d", "",
@@ -90,6 +98,8 @@ func init() {
 		"Start processing the application, requires 'register=true'.")
 	applicationCmd.Flags().StringVarP(&authorityOwnerAddressParam, "authority-owner", "O", "",
 		"Authority Owner address. If not defined, it will be derived from the auth method.")
+	applicationCmd.Flags().BoolVarP(&deploymentTypePRT, "prt", "", false,
+		"Deploy a PRT application.")
 
 	origHelpFunc := applicationCmd.HelpFunc()
 	applicationCmd.SetHelpFunc(func(command *cobra.Command, strings []string) {
@@ -146,7 +156,9 @@ func runDeployApplication(cmd *cobra.Command, args []string) {
 	}
 
 	var deployment ethutil.IApplicationDeployment
-	if deploySelfhosted := !cmd.Flags().Changed("consensus"); deploySelfhosted {
+	if deploymentTypePRT {
+		deployment, err = buildPrtApplicationDeployment(ctx, cmd, args, client, txOpts)
+	} else if deploySelfhosted := !cmd.Flags().Changed("consensus"); deploySelfhosted {
 		deployment, err = buildSelfhostedApplicationDeployment(ctx, cmd, args, client, txOpts)
 	} else {
 		deployment, err = buildApplicationOnlyDeployment(ctx, cmd, args, client, txOpts)
@@ -235,6 +247,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")
 	}
@@ -382,7 +403,7 @@ func buildSelfhostedApplicationDeployment(
 	return request, nil
 }
 
-func buildApplicationOnlyDeployment(
+func buildApplicationOnlyDeploymentWithoutConsensus(
 	ctx context.Context,
 	cmd *cobra.Command,
 	args []string,
@@ -404,11 +425,6 @@ func buildApplicationOnlyDeployment(
 		return nil, fmt.Errorf("error on parameter factory: %w", err)
 	}
 
-	request.Consensus, err = parseHexAddress(applicationConsensusAddressParam)
-	if err != nil {
-		return nil, fmt.Errorf("error on parameter consensus: %w", err)
-	}
-
 	if !cmd.Flags().Changed("template-hash") {
 		if len(args) >= 2 { // args[1] is mandatory if `template-hash` was absent
 			request.TemplateHash, err = readHash(args[1])
@@ -470,6 +486,60 @@ func buildApplicationOnlyDeployment(
 	return request, nil
 }
 
+func buildApplicationOnlyDeployment(
+	ctx context.Context,
+	cmd *cobra.Command,
+	args []string,
+	client *ethclient.Client,
+	txOpts *bind.TransactOpts,
+) (
+	*ethutil.ApplicationDeployment,
+	error,
+) {
+	request, err := buildApplicationOnlyDeploymentWithoutConsensus(ctx, cmd, args, client, txOpts)
+
+	request.Consensus, err = parseHexAddress(applicationConsensusAddressParam)
+	if err != nil {
+		return nil, fmt.Errorf("error on parameter consensus: %w", err)
+	}
+
+	request.Consensus, request.EpochLength, err = customConsensus(client, applicationConsensusAddressParam)
+	if err != nil {
+		return nil, fmt.Errorf("error on parameter consensus: %w", err)
+	}
+
+	return request, nil
+}
+
+func buildPrtApplicationDeployment(
+	ctx context.Context,
+	cmd *cobra.Command,
+	args []string,
+	client *ethclient.Client,
+	txOpts *bind.TransactOpts,
+) (
+	*ethutil.PRTApplicationDeployment,
+	error,
+) {
+	var err error
+	request := &ethutil.PRTApplicationDeployment{}
+	if !cmd.Flags().Changed("prt-factory") {
+		request.FactoryAddress, err = config.GetContractsPrtFactoryAddress()
+	} else {
+		request.FactoryAddress, err = parseHexAddress(factoryAddressParam)
+	}
+	if err != nil {
+		return nil, fmt.Errorf("error on parameter factory: %w", err)
+	}
+
+	request.Application, err = buildApplicationOnlyDeploymentWithoutConsensus(ctx, cmd, args, client, txOpts)
+	if err != nil {
+		return nil, fmt.Errorf("error on application: %w", err)
+	}
+
+	return request, nil
+}
+
 // read the hash value from the cartesi machine hash file
 func readHash(machineDir string) (common.Hash, error) {
 	zero := common.Hash{}

internal/config/generate/Config.toml

@@ -210,6 +210,13 @@ Address of the SelfHostedApplicationFactory contract. Not required, used only by
 omit = true
 used-by = ["cli"]
 
+[contracts.CARTESI_CONTRACTS_PRT_CONSENSUS_FACTORY_ADDRESS]
+go-type = "Address"
+description = """
+Address of the PRT consensus contract. Not required, used only by the CLI and tests"""
+omit = true
+used-by = ["cli"]
+
 #
 # Snapshot
 #

internal/config/generated.go

@@ -0,0 +1,148 @@
+// (c) Cartesi and individual authors (see AUTHORS)
+// SPDX-License-Identifier: Apache-2.0 (see LICENSE)
+package ethutil
+
+import (
+	"context"
+	"encoding/hex"
+	"fmt"
+	"math/big"
+
+	"github.com/cartesi/rollups-node/pkg/contracts/daveconsensusfactory"
+	"github.com/cartesi/rollups-node/pkg/contracts/iapplication"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+)
+
+type PRTApplicationDeployment struct {
+	FactoryAddress common.Address
+	TemplateHash   common.Hash
+	Salt           SaltBytes
+
+	Application *ApplicationDeployment
+}
+
+type PRTApplicationDeploymentResult struct {
+	Deployment        *PRTApplicationDeployment
+	ApplicationResult *ApplicationDeploymentResult
+}
+
+func (me *PRTApplicationDeployment) String() string {
+	result := ""
+	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("\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 *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,
+	applicationAddress common.Address,
+) (common.Address, error) {
+	zero := common.Address{}
+
+	factory, err := daveconsensusfactory.NewDaveConsensusFactory(me.FactoryAddress, client)
+	if err != nil {
+		return zero, fmt.Errorf("failed to instantiate contract: %v", err)
+	}
+	tx, err := factory.NewDaveConsensus(txOpts, applicationAddress, me.TemplateHash, me.Salt)
+	if err != nil {
+		return zero, 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)
+	}
+
+	if receipt.Status != 1 {
+		return zero, fmt.Errorf("transaction failed")
+	}
+
+	// Look for the specific event in the receipt logs
+	for _, vLog := range receipt.Logs {
+		// Parse log for DaveConsensusCreated event
+		event, err := factory.ParseDaveConsensusCreated(*vLog)
+		if err != nil {
+			continue // Skip logs that don't match
+		}
+		return event.DaveConsensus, nil
+	}
+	return zero, fmt.Errorf("failed to find DaveConsensusCreated event in receipt logs")
+}
+
+// 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 *PRTApplicationDeployment) Deploy(
+	ctx context.Context,
+	client *ethclient.Client,
+	txOpts *bind.TransactOpts,
+) (common.Address, IApplicationDeploymentResult, error) {
+	zero := common.Address{}
+	result := &PRTApplicationDeploymentResult{}
+	result.Deployment = me
+
+	var err error
+	applicationAddress, appResult, err := me.Application.Deploy(ctx, client, txOpts)
+	if err != nil {
+		return zero, nil, err
+	}
+
+	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)
+	}
+
+	application, err := iapplication.NewIApplication(applicationAddress, client)
+	if err != nil {
+		return zero, nil, fmt.Errorf("failed to instantiate application: %v", err)
+	}
+
+	_, err = sendTransaction(ctx, client, txOpts, big.NewInt(0), GasLimit,
+		func(txOpts *bind.TransactOpts) (*types.Transaction, error) {
+			return application.MigrateToOutputsMerkleRootValidator(txOpts, consensus)
+		},
+	)
+	if err != nil {
+		return zero, nil, fmt.Errorf("failed to create a self hosted application: execution reverted")
+	}
+
+	_, err = sendTransaction(ctx, client, txOpts, big.NewInt(0), GasLimit,
+		func(txOpts *bind.TransactOpts) (*types.Transaction, error) {
+			return application.RenounceOwnership(txOpts)
+		},
+	)
+	if err != nil {
+		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 *PRTApplicationDeployment) GetFactoryAddress() common.Address {
+	return me.FactoryAddress
+}