feat: update contracts to v2.0.0-rc.16 (WIP)

Author: vfusco

Makefile

@@ -18,10 +18,10 @@ TARGET_OS?=$(shell uname)
 export TARGET_OS
 
 ROLLUPS_NODE_VERSION := 2.0.0
-CONTRACTS_VERSION := 2.0.0-rc.12
+CONTRACTS_VERSION := 2.0.0-rc.16
 CONTRACTS_URL:=https://github.com/cartesi/rollups-contracts/releases/download/
 CONTRACTS_ARTIFACT:=rollups-contracts-$(CONTRACTS_VERSION)-artifacts.tar.gz
-CONTRACTS_SHA256:=6d2cd0d5f562342b5171766b0574043a39b8f74b276052b2150cdc26ec7a9fdf
+CONTRACTS_SHA256:=84241197e60e3d897bac1c473cf31d9197b01d6232e657457d1f16536bd49d81
 
 IMAGE_TAG ?= devel
 
@@ -69,7 +69,7 @@ endif
 
 GO_TEST_PACKAGES ?= ./...
 
-ROLLUPS_CONTRACTS_ABI_BASEDIR:= rollups-contracts/export/artifacts/contracts
+ROLLUPS_CONTRACTS_ABI_BASEDIR:= rollups-contracts/
 
 all: build
 
@@ -87,12 +87,11 @@ env:
 	@echo export CARTESI_BLOCKCHAIN_DEFAULT_BLOCK="latest"
 	@echo export CARTESI_BLOCKCHAIN_HTTP_ENDPOINT="http://localhost:8545"
 	@echo export CARTESI_BLOCKCHAIN_WS_ENDPOINT="ws://localhost:8545"
-	@echo export CARTESI_BLOCKCHAIN_ID="31337"
-	@echo export CARTESI_CONTRACTS_INPUT_BOX_ADDRESS="0x593E5BCf894D6829Dd26D0810DA7F064406aebB6"
-	@echo export CARTESI_CONTRACTS_INPUT_BOX_DEPLOYMENT_BLOCK_NUMBER="10"
-	@echo export CARTESI_CONTRACTS_AUTHORITY_FACTORY_ADDRESS="0xB897F7Fe78f220aE34B7FA9493092701a873Ed45"
-	@echo export CARTESI_CONTRACTS_APPLICATION_FACTORY_ADDRESS="0xd7d4d184b82b1a4e08f304DDaB0A2A7a301C2620"
-	@echo export CARTESI_CONTRACTS_SELF_HOSTED_APPLICATION_FACTORY_ADDRESS="0xF925E1467DfCb1be6904bcF70621A974b5eA8708"
+	@echo export CARTESI_BLOCKCHAIN_ID="13370"
+	@echo export CARTESI_CONTRACTS_INPUT_BOX_ADDRESS="0xBa3Cf8fB82E43D370117A0b7296f91ED674E94e3"
+	@echo export CARTESI_CONTRACTS_AUTHORITY_FACTORY_ADDRESS="0x175965d993BcaAFcdfB3699fdA04F15e6AD9B76B"
+	@echo export CARTESI_CONTRACTS_APPLICATION_FACTORY_ADDRESS="0x536Cd5028b046a7809A946c76C84Fe08377afA16"
+	@echo export CARTESI_CONTRACTS_SELF_HOSTED_APPLICATION_FACTORY_ADDRESS="0xf02Fc4C62FEc0b9442C1312a53327FA852975f0e"
 	@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_TEST_DATABASE_CONNECTION="postgres://test_user:password@localhost:5432/test_rollupsdb?sslmode=disable"
@@ -140,7 +139,7 @@ migrate: ## Run migration on development database
 generate-db: ## Generate repository/db with Jet
 	@echo "Generating internal/repository/postgres/db with jet"
 	@rm -rf internal/repository/postgres/db
-	@go run github.com/go-jet/jet/v2/cmd/jet -dsn=$$CARTESI_POSTGRES_ENDPOINT -schema=public -path=./internal/repository/postgres/db
+	@go run github.com/go-jet/jet/v2/cmd/jet -dsn=$$CARTESI_DATABASE_CONNECTION -schema=public -path=./internal/repository/postgres/db
 	@rm -rf internal/repository/postgres/db/rollupsdb/public/model
 
 # =============================================================================
@@ -277,9 +276,9 @@ copy-devnet-files deployment.json: ## Copy the devnet files to the host (it must
 start-postgres: ## Run the PostgreSQL 16 docker container
 	@echo "Starting portgres"
 	@docker run --rm --name postgres -p 5432:5432 -d -e POSTGRES_PASSWORD=password -e POSTGRES_DB=rollupsdb -v $(CURDIR)/test/postgres/init-test-db.sh:/docker-entrypoint-initdb.d/init-test-db.sh postgres:16-alpine
+	@$(MAKE) migrate
 
 start: start-postgres start-devnet ## Start the anvil devnet and PostgreSQL 16 docker containers
-	@$(MAKE) migrate
 
 stop-devnet: ## Stop the anvil devnet docker container
 	@docker stop devnet
@@ -291,7 +290,13 @@ stop: stop-devnet stop-postgres ## Stop all running docker containers
 
 restart-devnet: ## Restart the anvil devnet docker container
 	@$(MAKE) stop-devnet
-	@$(MAKE) run-devnet
+	@$(MAKE) start-devnet
+
+restart-postgres: ## Restart the PostgreSQL 16 docker container and migrate it
+	@$(MAKE) stop-postgres
+	@$(MAKE) start-postgres
+
+restart: restart-devnet restart-postgres ## Restart all running docker containers
 
 shutdown-compose: ## Remove the containers and volumes from previous compose run
 	@docker compose down -v

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

@@ -17,11 +17,12 @@ import (
 	"github.com/cartesi/rollups-node/internal/config/auth"
 	"github.com/cartesi/rollups-node/internal/model"
 	"github.com/cartesi/rollups-node/internal/repository/factory"
+	"github.com/cartesi/rollups-node/pkg/contracts/dataavailability"
 	"github.com/cartesi/rollups-node/pkg/contracts/iapplicationfactory"
 	"github.com/cartesi/rollups-node/pkg/contracts/iauthorityfactory"
 	"github.com/cartesi/rollups-node/pkg/contracts/iconsensus"
+	"github.com/cartesi/rollups-node/pkg/contracts/iinputbox"
 
-	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient"
@@ -46,11 +47,12 @@ var (
 	templatePath           string
 	templateHash           string
 	consensusAddr          string
+	inputBoxAddress        string
+	dataAvailability       string
 	appFactoryAddr         string
 	authorityFactoryAddr   string
 	blockchainHttpEndpoint string
 	salt                   string
-	inputBoxBlockNumber    uint64
 	epochLength            uint64
 	disabled               bool
 	printAsJSON            bool
@@ -76,6 +78,10 @@ func init() {
 		"Application template hash. If not provided, it will be read from the template path",
 	)
 
+	Cmd.Flags().StringVarP(&dataAvailability, "data-availability", "D", "",
+		"Application ABI encoded Data Availability. If not provided, it will be read from the InputBox Address",
+	)
+
 	Cmd.Flags().StringVarP(&appFactoryAddr, "application-factory", "a", "", "Application Factory Address")
 	viper.BindPFlag(config.CONTRACTS_APPLICATION_FACTORY_ADDRESS, Cmd.Flags().Lookup("application-factory"))
 
@@ -90,8 +96,8 @@ func init() {
 		"Consensus Epoch length. If consensus address is provided, the value will be read from the contract",
 	)
 
-	Cmd.Flags().Uint64VarP(&inputBoxBlockNumber, "inputbox-block-number", "i", 0, "InputBox deployment block number")
-	viper.BindPFlag(config.CONTRACTS_INPUT_BOX_DEPLOYMENT_BLOCK_NUMBER, Cmd.Flags().Lookup("inputbox-block-number"))
+	Cmd.Flags().StringVar(&inputBoxAddress, "inputbox", "", "Input Box contract address")
+	viper.BindPFlag(config.CONTRACTS_INPUT_BOX_ADDRESS, Cmd.Flags().Lookup("inputbox"))
 
 	Cmd.Flags().StringVar(&salt, "salt", "0000000000000000000000000000000000000000000000000000000000000000", "salt")
 
@@ -133,8 +139,18 @@ func run(cmd *cobra.Command, args []string) {
 	txOpts, err := auth.GetTransactOpts(chainId)
 	cobra.CheckErr(err)
 
+	inputBoxAddress, inputBoxBlock, encodedDA, err := processDataAvailability(client, cmd.Flags().Changed("data-availability"))
+	cobra.CheckErr(err)
+
 	var consensus common.Address
-	if consensusAddr == "" {
+	if cmd.Flags().Changed("consensus") {
+		consensus = common.HexToAddress(consensusAddr)
+		epochLength, err = getEpochLength(consensus)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Failed to get epoch length from consensus: %v\n", err)
+			os.Exit(1)
+		}
+	} else {
 		var owner common.Address
 		authorityFactoryAddress, err := config.GetContractsAuthorityFactoryAddress()
 		cobra.CheckErr(err)
@@ -148,24 +164,20 @@ func run(cmd *cobra.Command, args []string) {
 			fmt.Fprintf(os.Stderr, "Authoriy contract creation failed: %v\n", err)
 			os.Exit(1)
 		}
-	} else {
-		consensus = common.HexToAddress(consensusAddr)
-		epochLength, err = getEpochLength(consensus)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Failed to get epoch length from consensus: %v\n", err)
-			os.Exit(1)
-		}
 	}
 
+	var daSelector model.DataAvailabilitySelector
+	copy(daSelector[:], encodedDA[:model.DATA_AVAILABILITY_SELECTOR_SIZE])
+
 	var owner common.Address
 	if cmd.Flags().Changed("application-owner") {
 		owner = common.HexToAddress(applicationOwner)
 	} else {
 		owner = txOpts.From
 	}
-	applicationFactoryAddress, err := config.GetContractsApplicationFactoryAddress()
+	appFactoryAddress, err := config.GetContractsApplicationFactoryAddress()
 	cobra.CheckErr(err)
-	appAddr, err := deployApplication(ctx, client, txOpts, applicationFactoryAddress, consensus, owner, templateHash, salt)
+	appAddr, err := deployApplication(ctx, client, txOpts, appFactoryAddress, consensus, owner, templateHash, encodedDA, salt)
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Application contract creation failed: %v\n", err)
 		os.Exit(1)
@@ -175,13 +187,16 @@ func run(cmd *cobra.Command, args []string) {
 		Name:                 name,
 		IApplicationAddress:  appAddr,
 		IConsensusAddress:    consensus,
+		IInputBoxAddress:     *inputBoxAddress,
 		TemplateURI:          templatePath,
 		TemplateHash:         common.HexToHash(templateHash),
 		EpochLength:          epochLength,
+		DataAvailability:     daSelector,
 		State:                applicationState,
-		LastProcessedBlock:   inputBoxBlockNumber,
-		LastOutputCheckBlock: inputBoxBlockNumber,
-		LastClaimCheckBlock:  inputBoxBlockNumber,
+		IInputBoxBlock:       inputBoxBlock.Uint64(),
+		LastProcessedBlock:   0,
+		LastOutputCheckBlock: 0,
+		LastClaimCheckBlock:  0,
 	}
 
 	if !noRegister {
@@ -208,7 +223,7 @@ func run(cmd *cobra.Command, args []string) {
 	}
 }
 
-// FIXME remove this
+// FIXME move this to ethutil
 func deployApplication(
 	ctx context.Context,
 	client *ethclient.Client,
@@ -217,6 +232,7 @@ func deployApplication(
 	authorityAddr common.Address,
 	owner common.Address,
 	templateHash string,
+	dataAvailability []byte,
 	salt string,
 ) (common.Address, error) {
 
@@ -234,7 +250,7 @@ func deployApplication(
 		return common.Address{}, fmt.Errorf("Failed to instantiate contract: %v", err)
 	}
 
-	tx, err := factory.NewApplication(txOpts, authorityAddr, owner, toBytes32(templateHashBytes), toBytes32(saltBytes))
+	tx, err := factory.NewApplication(txOpts, authorityAddr, owner, toBytes32(templateHashBytes), dataAvailability, toBytes32(saltBytes))
 	if err != nil {
 		return common.Address{}, fmt.Errorf("Transaction failed: %v", err)
 	}
@@ -257,23 +273,10 @@ func deployApplication(
 		return common.Address{}, fmt.Errorf("Transaction failed!")
 	}
 
-	// Parse logs to get the address of the new application contract
-	contractABI, err := abi.JSON(strings.NewReader(iapplicationfactory.IApplicationFactoryABI))
-	if err != nil {
-		return common.Address{}, fmt.Errorf("Failed to parse ABI: %v", err)
-	}
-
 	// Look for the specific event in the receipt logs
 	for _, vLog := range receipt.Logs {
-		event := struct {
-			Consensus    common.Address
-			AppOwner     common.Address
-			TemplateHash [32]byte
-			AppContract  common.Address
-		}{}
-
 		// Parse log for ApplicationCreated event
-		err := contractABI.UnpackIntoInterface(&event, "ApplicationCreated", vLog.Data)
+		event, err := factory.ParseApplicationCreated(*vLog)
 		if err != nil {
 			continue // Skip logs that don't match
 		}
@@ -330,20 +333,10 @@ func deployAuthority(
 		return common.Address{}, fmt.Errorf("Transaction failed!")
 	}
 
-	// Parse logs to get the address of the new application contract
-	contractABI, err := abi.JSON(strings.NewReader(iauthorityfactory.IAuthorityFactoryABI))
-	if err != nil {
-		return common.Address{}, fmt.Errorf("Failed to parse ABI: %v", err)
-	}
-
 	// Look for the specific event in the receipt logs
 	for _, vLog := range receipt.Logs {
-		event := struct {
-			Authority common.Address
-		}{}
-
 		// Parse log for ApplicationCreated event
-		err := contractABI.UnpackIntoInterface(&event, "AuthorityCreated", vLog.Data)
+		event, err := contract.ParseAuthorityCreated(*vLog)
 		if err != nil {
 			continue // Skip logs that don't match
 		}
@@ -380,6 +373,79 @@ func getEpochLength(
 	return epochLengthRaw.Uint64(), nil
 }
 
+func processDataAvailability(
+	client *ethclient.Client,
+	hasDataAvailabilityFlag bool,
+) (*common.Address, *big.Int, []byte, error) {
+	var inputBoxAddress common.Address
+	var encodedDA []byte
+	var err error
+
+	parsedAbi, err := dataavailability.DataAvailabilityMetaData.GetAbi()
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("failed to get ABI: %w", err)
+	}
+
+	if hasDataAvailabilityFlag {
+		if len(dataAvailability) < 3 || (!strings.HasPrefix(dataAvailability, "0x") && !strings.HasPrefix(dataAvailability, "0X")) {
+			return nil, nil, nil, fmt.Errorf("data Availability should be an ABI encoded value")
+		}
+
+		s := dataAvailability[2:]
+		encodedDA, err = hex.DecodeString(s)
+		if err != nil {
+			return nil, nil, nil, fmt.Errorf("error parsing Data Availability value: %w", err)
+		}
+
+		if len(encodedDA) < model.DATA_AVAILABILITY_SELECTOR_SIZE {
+			return nil, nil, nil, fmt.Errorf("invalid Data Availability")
+		}
+
+		method, err := parsedAbi.MethodById(encodedDA[:model.DATA_AVAILABILITY_SELECTOR_SIZE])
+		if err != nil {
+			return nil, nil, nil, fmt.Errorf("failed to get method by ID: %w", err)
+		}
+
+		args, err := method.Inputs.Unpack(encodedDA[model.DATA_AVAILABILITY_SELECTOR_SIZE:])
+		if err != nil {
+			return nil, nil, nil, fmt.Errorf("failed to unpack inputs: %w", err)
+		}
+
+		if len(args) == 0 {
+			return nil, nil, nil, fmt.Errorf("invalid Data Availability. Should at least contain InputBox Address")
+		}
+
+		switch addr := args[0].(type) {
+		case common.Address:
+			inputBoxAddress = addr
+		default:
+			return nil, nil, nil, fmt.Errorf("first argument in Data Availability is not an address (got %T)", args[0])
+		}
+	} else {
+		inputBoxAddress, err = config.GetContractsInputBoxAddress()
+		if err != nil {
+			return nil, nil, nil, fmt.Errorf("failed to get input box address: %w", err)
+		}
+
+		encodedDA, err = parsedAbi.Pack("InputBox", inputBoxAddress)
+		if err != nil {
+			return nil, nil, nil, fmt.Errorf("failed to pack InputBox: %w", err)
+		}
+	}
+
+	inputbox, err := iinputbox.NewIInputBox(inputBoxAddress, client)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("failed to create input box instance: %w", err)
+	}
+
+	inputBoxBlock, err := inputbox.GetDeploymentBlockNumber(nil)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("failed to get deployment block number: %w", err)
+	}
+
+	return &inputBoxAddress, inputBoxBlock, encodedDA, nil
+}
+
 func toBytes32(data []byte) [32]byte {
 	var arr [32]byte
 	if len(data) != 32 {