Makefile.devnet

.PHONY: devnet-build devnet-tests-build _devnet-stage-migration-scripts devnet-up devnet-reset devnet-up-detach devnet-down devnet-stop devnet-clean devnet-deploy-tar devnet-upgrade devnet-new devnet-start devnet-evm-upgrade
.PHONY: devnet-build-default _devnet-select-default-genesis devnet-refresh-bin devnet-update-binaries devnet-update-binaries-default devnet-update-scripts
.PHONY: devnet-build-version devnet-new-version devnet-upgrade-version devnet-stage-external-version devnet-new-remote-version devnet-remote-upgrade-version
.PHONY: _check-devnet-version-bin _check-devnet-build-version-cfg _check-devnet-external-version-cfg
.PHONY: devnet-download-binaries
.PHONY: devnet-evmigration-sync-bin devnet-evmigration-prepare devnet-evmigration-estimate devnet-evmigration-migrate devnet-evmigration-migrate-validator devnet-evmigration-verify devnet-evmigration-cleanup
.PHONY: devnet-evmigrationp-prepare devnet-evmigrationp-estimate devnet-evmigrationp-migrate devnet-evmigrationp-migrate-validator devnet-evmigrationp-migrate-all devnet-evmigrationp-verify devnet-evmigrationp-cleanup
.PHONY: devnet-tests-everlight devnet-tests-lep6 devnet-new-no-hermes

##### Devnet Makefile ########################################
#
# Targets for managing a local Dockerized devnet (5 validators + Hermes
# relayer). State lives in /tmp/lumera-devnet-1/ and devnet/bin*/.
#
# -- Build from local source -----------------------------------
#   make devnet-tests-build                         # build tests_validator/tests_hermes/tests_evmigration/tests-gen-activity
#   make devnet-build-default                       # build + configure using locally compiled lumerad
#   make devnet-refresh-bin                         # rebuild lumerad and copy into devnet/bin/
#
# -- Release binaries (devnet/config/binaries.json) -----------------------------------------
#   make devnet-download-binaries VERSION=v1.12.0   # download lumerad/supernode/uploader/sncli into devnet/bin-<VERSION>/
#   make devnet-build-version     VERSION=v1.12.0   # build + configure using those binaries
#   make devnet-new-version       VERSION=v1.12.0   # clean + build-version + up
#   make devnet-upgrade-version   VERSION=v1.12.0   # update running devnet to those binaries
#
# -- Remote execution from downloaded binaries -----------------
#   make devnet-stage-external-version VERSION=v1.12.0   # local staging only, no Docker build, Hermes disabled
#   make devnet-new-remote-version VERSION=v1.12.0       # stage locally, run on REMOTE_DEVNET_HOST
#   make devnet-remote-upgrade-version VERSION=v1.20.0   # in-place upgrade of the running REMOTE_DEVNET_HOST devnet
#
# -- Lifecycle (on an already-built devnet) --------------------
#   make devnet-up                                  # start containers (foreground)
#   make devnet-up-detach                           # start containers (background)
#   make devnet-stop / make devnet-start            # stop / start without wiping state
#   make devnet-down                                # stop and remove containers
#   make devnet-clean                               # wipe all devnet state (requires sudo)
#   make devnet-reset                               # reset validator keys, keep config
#
# -- Full reset + rebuild + start ------------------------------
#   make devnet-new                                 # down + clean + build-default + up
#   make devnet-new-version VERSION=v1.12.0         # same, using a pre-downloaded release
#
# -- In-place upgrade (while devnet is running) ----------------
#   make devnet-upgrade-version VERSION=v1.12.0     # upgrade to a pre-downloaded release
#   make devnet-upgrade-1201                        # upgrade to locally-built v1.20.1 (EVM)
#   make devnet-evm-upgrade                         # scripted v1.12.0 -> v1.20.1 evmigration flow
#
# -- External genesis / claims (override inputs to devnet-build) --
#   make devnet-build \
#       EXTERNAL_GENESIS_FILE=~/genesis.json
#   # Optional: EXTERNAL_CLAIMS_FILE=~/claims.csv
#   # Optional: CONFIG_JSON=path/to/config.json VALIDATORS_JSON=path/to/validators.json
#
# -- Container maintenance -------------------------------------
#   make devnet-update-scripts                      # push updated devnet/scripts/*.sh + scripts/migrate-*.sh into running containers
#   make devnet-update-binaries                     # push updated lumera binaries into running containers
#   make devnet-update-binaries-default             # push binaries from devnet/bin/ into running containers
#   make devnet-deploy-tar                          # stage a built release tar into /shared/release/
#
# -- EVM migration (per-validator tools) -----------------------
#   make devnet-evmigration-prepare                 # one-at-a-time per validator
#   make devnet-evmigration-verify                  # verify one-at-a-time migration state
#   make devnet-evmigrationp-prepare                # parallel across validators
#   make devnet-evmigrationp-migrate-all            # parallel account + validator migration flow
#   make devnet-evmigrationp-verify                 # parallel migration state verification
#   # also available: estimate / migrate / migrate-validator / cleanup
#
# Tip: any `devnet-*-<N>` alias (e.g. devnet-build-1111, devnet-new-1120)
# is a thin delegator to the corresponding `-version VERSION=vX.Y.Z` target.
##############################################################

DEVNET_DIR := /tmp/lumera-devnet-1
SHARED_DIR := ${DEVNET_DIR}/shared
SHARED_RELEASE_DIR := ${SHARED_DIR}/release
SHARED_CONFIG_DIR := ${SHARED_DIR}/config
VALIDATOR_DIRS := $(wildcard ${DEVNET_DIR}/supernova_validator*-data)
HERMES_SIMD_DIR := ${DEVNET_DIR}/hermes-simd-data
HERMES_ROUTER_DIR := ${DEVNET_DIR}/hermes-router
EXTERNAL_GENESIS := $(SHARED_CONFIG_DIR)/external_genesis.json
CLAIMS_FILE := $(SHARED_CONFIG_DIR)/claims.csv
COMPOSE_FILE := devnet/docker-compose.yml

DEVNET_BUILD_LUMERA ?= 1      # 1 = build lumerad for devnet setup, 0 = skip
DEVNET_BUILD_TESTS ?= 1       # 1 = build devnet test helper binaries, 0 = use existing/skip
DEVNET_DOCKER_BUILD ?= 1      # 1 = build Docker images after staging, 0 = only stage runtime files
# directory to take lumerad/supernode/lumera-uploader/sncli binaries from
DEVNET_BIN_DIR ?= devnet/bin
DEVNET_BIN_DIR_ABS := $(abspath $(DEVNET_BIN_DIR))

# Default paths for configuration files
DEFAULT_CONFIG_JSON := config/config.json
DEFAULT_VALIDATORS_JSON := config/validators.json

# Default genesis and claims files for devnet docker
DEFAULT_GENESIS_FILE := devnet/default-config/devnet-genesis.json
DEFAULT_GENESIS_EVM_FILE := devnet/default-config/devnet-genesis-evm.json
DEFAULT_CLAIMS_FILE := devnet/default-config/claims.csv
ORIG_GENESIS_FILE := devnet/default-config/devnet-genesis-orig.json
EVM_CUTOVER_VERSION ?= v1.20.0
DEVNET_UPGRADE_RELEASE ?= auto
REMOTE_DEVNET_HOST ?= lumera-devnet
REMOTE_DEVNET_DIR ?= lumera-devnet
REMOTE_DEVNET_SSH ?= ssh
REMOTE_DEVNET_RSYNC ?= rsync -az
REMOTE_EXTERNAL_GENESIS_FILE ?= $(HOME)/external-genesis/lumera-devnet-1/genesis.json
REMOTE_DEVNET_STAGE_DIR ?= $(abspath build/devnet-remote-stage/lumera-devnet-1)
REMOTE_CONFIG_JSON ?= $(REMOTE_DEVNET_STAGE_DIR)/config-no-hermes.json
DEVNET_EXTERNAL_GENESIS_FILE = $(or $(EXTERNAL_GENESIS_FILE),$(REMOTE_EXTERNAL_GENESIS_FILE))

devnet-tests-build:
	@mkdir -p "${DEVNET_BIN_DIR_ABS}"
	@echo "Tidying devnet go modules..."
	@cd devnet && $(GO) mod tidy
	@echo "Building devnet test binaries..."
	@echo "  -> building tests_validator (${DEVNET_BIN_DIR_ABS}/tests_validator)"
	@cd devnet && $(GO) test -c -o "${DEVNET_BIN_DIR_ABS}/tests_validator" ./tests/validator
	@echo "  -> building tests_hermes (${DEVNET_BIN_DIR_ABS}/tests_hermes)"
	@cd devnet && $(GO) test -c -o "${DEVNET_BIN_DIR_ABS}/tests_hermes" ./tests/hermes
	@echo "  -> building tests_evmigration (${DEVNET_BIN_DIR_ABS}/tests_evmigration)"
	@cd devnet && $(GO) build -o "${DEVNET_BIN_DIR_ABS}/tests_evmigration" ./tests/evmigration
	@echo "  -> building tests-gen-activity (${DEVNET_BIN_DIR_ABS}/tests-gen-activity)"
	@cd devnet && $(GO) build -o "${DEVNET_BIN_DIR_ABS}/tests-gen-activity" ./tests/gen-activity
	@echo "Devnet test binaries built successfully"

# Mirror the public migration helper scripts from the repo-root scripts/ into
# the devnet docker build context so the dockerfile can COPY them. The mirror
# is a build artifact (gitignored); the canonical sources live at <repo>/scripts/.
# Mirrors the same set the root Makefile's `release` target packages into the
# tarball, so devnet containers expose the same migration tooling end-users get.
_devnet-stage-migration-scripts:
	@mkdir -p devnet/scripts/migration
	@cp -f \
		scripts/evmigration-common.sh \
		scripts/migrate-account.sh \
		scripts/migrate-multisig.sh \
		scripts/migrate-validator.sh \
		devnet/scripts/migration/
	@chmod +x devnet/scripts/migration/migrate-account.sh \
		devnet/scripts/migration/migrate-multisig.sh \
		devnet/scripts/migration/migrate-validator.sh
	@echo "Staged migration scripts at devnet/scripts/migration/ for docker build"

devnet-build:
	@mkdir -p "$(SHARED_RELEASE_DIR)"; \
	if [ -n "$(EXTERNAL_GENESIS_FILE)" ] && [ -f "$(EXTERNAL_GENESIS_FILE)" ]; then \
		echo "Starting devnet with existing genesis from $(EXTERNAL_GENESIS_FILE) ..."; \
		mkdir -p "$(SHARED_CONFIG_DIR)"; \
		cp -f "$(EXTERNAL_GENESIS_FILE)" "$(EXTERNAL_GENESIS)"; \
		export EXTERNAL_GENESIS_FILE=1; \
	else \
		echo "No external genesis file provided or file not found. Using default initialization..."; \
		export EXTERNAL_GENESIS_FILE=0; \
	fi; \
	if [ -n "$(EXTERNAL_CLAIMS_FILE)" ] && [ -f "$(EXTERNAL_CLAIMS_FILE)" ]; then \
		cp -f "$(EXTERNAL_CLAIMS_FILE)" "$(CLAIMS_FILE)"; \
		echo "Using claims file $(EXTERNAL_CLAIMS_FILE)"; \
	else \
		if [ -n "$(EXTERNAL_CLAIMS_FILE)" ]; then \
			echo "External claims file not found: $(EXTERNAL_CLAIMS_FILE)"; \
			exit 1; \
		fi; \
		rm -f "$(CLAIMS_FILE)"; \
		echo "No external claims file provided; claims.csv will not be staged."; \
	fi; \
	EXTERNAL_GENESIS_FILE=$${EXTERNAL_GENESIS_FILE}; \
	mkdir -p "${DEVNET_BIN_DIR}"; \
	if [ "$(DEVNET_BUILD_LUMERA)" -eq "1" ]; then \
		$(MAKE) build; \
		if [ ! -f "${BUILD_DIR}/lumerad" ]; then \
			echo "Cannot find lumerad binary [${BUILD_DIR}/lumerad]"; \
			exit 1; \
		fi; \
		echo "Copying [${BUILD_DIR}/lumerad] to [${DEVNET_BIN_DIR}] directory..."; \
		cp -f ${BUILD_DIR}/lumerad "${DEVNET_BIN_DIR}"; \
		go get github.com/CosmWasm/wasmvm/$(WASMVM_VERSION); \
		find $$(go env GOPATH)/pkg/mod/github.com/!cosm!wasm/wasmvm/$(WASMVM_VERSION) -name "libwasmvm.x86_64.so" -exec cp -f {} ${DEVNET_BIN_DIR}/libwasmvm.x86_64.so \; ; \
	else \
		echo "Using existing lumera binaries from ${DEVNET_BIN_DIR}..."; \
	fi; \
	if [ ! -f "${DEVNET_BIN_DIR}/lumerad" ]; then \
		echo "${DEVNET_BIN_DIR}/lumerad binary not found..."; \
		exit 1; \
	fi; \
	if [ ! -f "${DEVNET_BIN_DIR}/libwasmvm.x86_64.so" ]; then \
		echo "${DEVNET_BIN_DIR}/libwasmvm.x86_64.so library not found..."; \
		exit 1; \
	fi; \
	if [ "$${EXTERNAL_GENESIS_FILE}" = "1" ] && [ ! -f "$(CLAIMS_FILE)" ]; then \
		CLAIM_TOTAL="$$(jq -r 'try (.app_state.claim.total_claimable_amount // "0") catch "0"' "$(EXTERNAL_GENESIS)")"; \
		if [ "$${CLAIM_TOTAL}" != "0" ] && [ "$${CLAIM_TOTAL}" != "null" ] && ! "${DEVNET_BIN_DIR}/lumerad" start --help 2>&1 | grep -q -- '--skip-claims-check'; then \
			echo "External genesis has claim.total_claimable_amount=$${CLAIM_TOTAL}, but no claims CSV was provided and ${DEVNET_BIN_DIR}/lumerad cannot skip claims loading."; \
			echo "Set app_state.claim.total_claimable_amount to 0 for a no-claims devnet or provide EXTERNAL_CLAIMS_FILE."; \
			exit 1; \
		fi; \
	fi; \
	if [ "$(DEVNET_BUILD_TESTS)" = "1" ]; then \
		$(MAKE) devnet-tests-build DEVNET_BIN_DIR="${DEVNET_BIN_DIR}"; \
	else \
		echo "Skipping devnet test binary build (DEVNET_BUILD_TESTS=0)."; \
	fi; \
	cp -f "${DEVNET_BIN_DIR}/lumerad" "${SHARED_RELEASE_DIR}/"; \
	cp -f "${DEVNET_BIN_DIR}/libwasmvm.x86_64.so" "${SHARED_RELEASE_DIR}/"; \
	$(MAKE) _devnet-stage-migration-scripts; \
	cd devnet && \
	${GO} mod tidy && \
	CONFIG_JSON="$${CONFIG_JSON:-$(DEFAULT_CONFIG_JSON)}" \
	VALIDATORS_JSON="$${VALIDATORS_JSON:-$(DEFAULT_VALIDATORS_JSON)}" \
	DEVNET_SHARED_DIR="$(SHARED_DIR)" \
	./scripts/configure.sh --bin-dir "${DEVNET_BIN_DIR}" &&\
	DEVNET_SHARED_DIR="$(SHARED_DIR)" \
	DEVNET_BIN_DIR="${DEVNET_BIN_DIR_ABS}" \
	${GO} run . && \
	if [ "$(DEVNET_DOCKER_BUILD)" = "1" ]; then \
		START_MODE=bootstrap docker compose build; \
	else \
		echo "Skipping local docker compose build (DEVNET_DOCKER_BUILD=0)."; \
	fi && \
	echo "Initialization complete. Ready to start nodes."

devnet-build-default:
	@GENESIS_FILE="$$( $(MAKE) --no-print-directory _devnet-select-default-genesis )"; \
	echo "Using default genesis template: $$GENESIS_FILE"; \
	$(MAKE) devnet-build \
		DEVNET_BUILD_LUMERA=$(DEVNET_BUILD_LUMERA) \
		EXTERNAL_GENESIS_FILE="$$(realpath "$$GENESIS_FILE")" \
		EXTERNAL_CLAIMS_FILE="$$(realpath $(DEFAULT_CLAIMS_FILE))"

# Build devnet from pre-downloaded binaries for a specific lumera version.
# Expects devnet/bin-<VERSION>/ to already contain the binaries (populate with
# `make devnet-download-binaries VERSION=<VERSION>`). The genesis template is
# auto-selected based on VERSION vs EVM_CUTOVER_VERSION.
# Usage: make devnet-build-version VERSION=v1.12.0
devnet-build-version: _check-devnet-build-version-cfg
	@GENESIS_FILE="$$( LUMERA_VERSION=$(VERSION) $(MAKE) --no-print-directory _devnet-select-default-genesis )"; \
	echo "Using genesis template: $$GENESIS_FILE for $(VERSION)"; \
	$(MAKE) devnet-build \
		DEVNET_BUILD_LUMERA=0 \
		DEVNET_BIN_DIR=devnet/bin-$(VERSION) \
		EXTERNAL_GENESIS_FILE="$$(realpath "$$GENESIS_FILE")" \
		EXTERNAL_CLAIMS_FILE="$$(realpath $(DEFAULT_CLAIMS_FILE))"

# Stage a devnet runtime from an external genesis and pre-downloaded versioned
# binaries. This is intended for remote execution workflows: it generates the
# compose file and /tmp/<chain-id>/shared locally without building Docker images.
# Usage: make devnet-stage-external-version VERSION=v1.12.0
# Optional: EXTERNAL_GENESIS_FILE=/path/to/genesis.json EXTERNAL_CLAIMS_FILE=/path/to/claims.csv
devnet-stage-external-version: _check-devnet-external-version-cfg
	@rm -rf "$(REMOTE_DEVNET_STAGE_DIR)"
	@mkdir -p "$(REMOTE_DEVNET_STAGE_DIR)"
	@jq '.hermes.enabled = false' devnet/config/config.json > "$(REMOTE_CONFIG_JSON)"
	@$(MAKE) devnet-build \
		DEVNET_DIR="$(REMOTE_DEVNET_STAGE_DIR)" \
		DEVNET_BUILD_LUMERA=0 \
		DEVNET_BUILD_TESTS=0 \
		DEVNET_DOCKER_BUILD=0 \
		DEVNET_BIN_DIR=devnet/bin-$(VERSION) \
		CONFIG_JSON="$(REMOTE_CONFIG_JSON)" \
		EXTERNAL_GENESIS_FILE="$$(realpath "$(DEVNET_EXTERNAL_GENESIS_FILE)")" \
		$(if $(EXTERNAL_CLAIMS_FILE),EXTERNAL_CLAIMS_FILE="$$(realpath "$(EXTERNAL_CLAIMS_FILE)")",)

# Build/stage locally from downloaded binaries, then run the Dockerized devnet
# on a remote host. The remote host only needs ssh access plus Docker Compose.
# Usage: make devnet-new-remote-version VERSION=v1.12.0
devnet-new-remote-version: devnet-stage-external-version
	@$(REMOTE_DEVNET_SSH) $(REMOTE_DEVNET_HOST) 'set -e; \
		command -v docker >/dev/null; \
		docker compose version >/dev/null; \
		mkdir -p $(REMOTE_DEVNET_DIR)/devnet; \
		if [ -f $(REMOTE_DEVNET_DIR)/devnet/docker-compose.yml ]; then \
			cd $(REMOTE_DEVNET_DIR)/devnet && docker compose down --remove-orphans || true; \
		fi; \
		if command -v sudo >/dev/null 2>&1 && sudo -n true >/dev/null 2>&1; then \
			sudo rm -rf $(DEVNET_DIR); \
		elif rm -rf $(DEVNET_DIR) 2>/tmp/lumera-devnet-rm.err; then \
			:; \
		elif command -v docker >/dev/null 2>&1; then \
			docker run --rm -v /tmp:/host-tmp busybox:1.36 sh -c "rm -rf /host-tmp/$$(basename $(DEVNET_DIR))" || { cat /tmp/lumera-devnet-rm.err >&2; rm -f /tmp/lumera-devnet-rm.err; exit 1; }; \
		else \
			cat /tmp/lumera-devnet-rm.err >&2; \
			rm -f /tmp/lumera-devnet-rm.err; \
			exit 1; \
		fi; \
		rm -f /tmp/lumera-devnet-rm.err; \
		mkdir -p $(REMOTE_DEVNET_DIR)/devnet $(SHARED_DIR)'
	@$(REMOTE_DEVNET_RSYNC) --delete \
		devnet/docker-compose.yml \
		devnet/dockerfile \
		devnet/scripts \
		devnet/hermes \
		$(REMOTE_DEVNET_HOST):$(REMOTE_DEVNET_DIR)/devnet/
	@$(REMOTE_DEVNET_RSYNC) --delete \
		$(REMOTE_DEVNET_STAGE_DIR)/shared/ \
		$(REMOTE_DEVNET_HOST):$(SHARED_DIR)/
	@# Stage the gen-activity tool config into the shared release dir, but only if
	@# it is missing on the host (--ignore-existing), so an edited config survives.
	@$(REMOTE_DEVNET_SSH) $(REMOTE_DEVNET_HOST) 'mkdir -p $(SHARED_RELEASE_DIR)'
	@$(REMOTE_DEVNET_RSYNC) --ignore-existing \
		devnet/config/gen-activity-config.toml \
		$(REMOTE_DEVNET_HOST):$(SHARED_RELEASE_DIR)/gen-activity-config.toml
	@$(REMOTE_DEVNET_SSH) $(REMOTE_DEVNET_HOST) 'set -e; \
		cd $(REMOTE_DEVNET_DIR)/devnet; \
		docker compose build; \
		START_MODE=auto docker compose up -d --remove-orphans; \
		docker compose ps'

# In-place upgrade of a devnet already running on REMOTE_DEVNET_HOST (started via
# devnet-new-remote-version) to a pre-downloaded lumera version. Pushes the new
# binaries (devnet/bin-<VERSION>/) and current scripts to the host, then runs the
# governance software-upgrade flow (scripts/upgrade.sh) there. Chain state is
# preserved (no clean, no genesis staging, no Docker rebuild).
#
# EVM cutover handling: if this upgrade crosses the pre-EVM -> EVM boundary
# (old version < EVM_CUTOVER_VERSION <= new version), it additionally regenerates
# docker-compose.yml for the new version (which now publishes the EVM host ports),
# rsyncs only that compose, and runs scripts/apply-evm-ports.sh on the host to
# reapply the metrics/geth bind config and recreate the containers. Chain data
# lives in host bind mounts, so it is preserved across the recreate.
#
# Requires devnet/bin-<VERSION>/lumerad locally (run devnet-download-binaries first)
# and a running remote devnet.
#
# Usage: make devnet-remote-upgrade-version VERSION=v1.20.0
devnet-remote-upgrade-version: _check-devnet-version-bin
	@set -e; \
	ver_ge() { printf '%s\n' "$$2" "$$1" | sort -V | head -n1 | grep -q "^$$2$$"; }; \
	new_ver="$(VERSION)"; case "$$new_ver" in v*) ;; *) new_ver="v$$new_ver";; esac; \
	cutover="$(EVM_CUTOVER_VERSION)"; case "$$cutover" in v*) ;; *) cutover="v$$cutover";; esac; \
	echo "==> Querying current remote devnet version..."; \
	old_ver="$$($(REMOTE_DEVNET_SSH) $(REMOTE_DEVNET_HOST) 'cd $(REMOTE_DEVNET_DIR)/devnet 2>/dev/null && docker compose exec -T supernova_validator_1 lumerad version 2>/dev/null | head -n1 | tr -d "\r"' 2>/dev/null || true)"; \
	case "$$old_ver" in v*|"") ;; *) old_ver="v$$old_ver";; esac; \
	echo "==> Remote running version: $${old_ver:-unknown}; upgrading to $$new_ver"; \
	$(REMOTE_DEVNET_SSH) $(REMOTE_DEVNET_HOST) 'set -e; \
		command -v docker >/dev/null; \
		docker compose version >/dev/null; \
		if [ ! -f $(REMOTE_DEVNET_DIR)/devnet/docker-compose.yml ]; then \
			echo "No remote devnet found at $(REMOTE_DEVNET_DIR)/devnet; run devnet-new-remote-version first" >&2; \
			exit 1; \
		fi; \
		mkdir -p $(REMOTE_DEVNET_DIR)/devnet/bin-$(VERSION)'; \
	$(REMOTE_DEVNET_RSYNC) --delete devnet/bin-$(VERSION)/ $(REMOTE_DEVNET_HOST):$(REMOTE_DEVNET_DIR)/devnet/bin-$(VERSION)/; \
	$(REMOTE_DEVNET_RSYNC) --delete devnet/scripts $(REMOTE_DEVNET_HOST):$(REMOTE_DEVNET_DIR)/devnet/; \
	$(REMOTE_DEVNET_SSH) $(REMOTE_DEVNET_HOST) 'set -e; cd $(REMOTE_DEVNET_DIR)/devnet/scripts; ./upgrade.sh $(VERSION) auto-height ../bin-$(VERSION)'; \
	if ver_ge "$$new_ver" "$$cutover" && { [ -z "$$old_ver" ] || ! ver_ge "$$old_ver" "$$cutover"; }; then \
		echo "==> EVM cutover crossed ($${old_ver:-pre-EVM} -> $$new_ver); exposing EVM host ports (data preserved)..."; \
		tmp_cfg="$$(mktemp)"; \
		jq '.hermes.enabled = false | .chain.version = "'"$$new_ver"'"' devnet/config/config.json > "$$tmp_cfg"; \
		( cd devnet && CONFIG_JSON="$$tmp_cfg" VALIDATORS_JSON="config/validators.json" EXTERNAL_GENESIS_FILE=0 $(GO) run . ); \
		rm -f "$$tmp_cfg"; \
		$(REMOTE_DEVNET_RSYNC) devnet/docker-compose.yml $(REMOTE_DEVNET_HOST):$(REMOTE_DEVNET_DIR)/devnet/docker-compose.yml; \
		$(REMOTE_DEVNET_SSH) $(REMOTE_DEVNET_HOST) 'set -e; cd $(REMOTE_DEVNET_DIR)/devnet/scripts; ./apply-evm-ports.sh'; \
		echo "==> EVM host ports applied."; \
	else \
		echo "==> No EVM cutover crossing (old=$${old_ver:-unknown}, new=$$new_ver, cutover=$$cutover); compose/ports unchanged."; \
	fi

_check-devnet-version-bin:
	@if [ -z "$(VERSION)" ]; then \
		echo "VERSION is required (e.g. VERSION=v1.12.0)"; \
		exit 1; \
	fi
	@if [ ! -f "devnet/bin-$(VERSION)/lumerad" ]; then \
		echo "Missing binary: devnet/bin-$(VERSION)/lumerad"; \
		echo "Run: make devnet-download-binaries VERSION=$(VERSION)"; \
		exit 1; \
	fi

_check-devnet-build-version-cfg: _check-devnet-version-bin
	@[ -f "$$(realpath $(DEFAULT_GENESIS_FILE))" ] || (echo "Missing DEFAULT_GENESIS_FILE: $(DEFAULT_GENESIS_FILE)"; exit 1)
	@[ -f "$$(realpath $(DEFAULT_GENESIS_EVM_FILE))" ] || (echo "Missing DEFAULT_GENESIS_EVM_FILE: $(DEFAULT_GENESIS_EVM_FILE)"; exit 1)
	@[ -f "$$(realpath $(DEFAULT_CLAIMS_FILE))" ] || (echo "Missing DEFAULT_CLAIMS_FILE: $(DEFAULT_CLAIMS_FILE)"; exit 1)

_check-devnet-external-version-cfg: _check-devnet-version-bin
	@if [ -z "$(DEVNET_EXTERNAL_GENESIS_FILE)" ]; then \
		echo "EXTERNAL_GENESIS_FILE is required (default: $(REMOTE_EXTERNAL_GENESIS_FILE))"; \
		exit 1; \
	fi
	@[ -f "$$(realpath "$(DEVNET_EXTERNAL_GENESIS_FILE)")" ] || (echo "Missing EXTERNAL_GENESIS_FILE: $(DEVNET_EXTERNAL_GENESIS_FILE)"; exit 1)
	@if [ -n "$(EXTERNAL_CLAIMS_FILE)" ] && [ ! -f "$(EXTERNAL_CLAIMS_FILE)" ]; then \
		echo "Missing EXTERNAL_CLAIMS_FILE: $(EXTERNAL_CLAIMS_FILE)"; \
		exit 1; \
	fi

.PHONY: devnet-build-1111 devnet-build-1120
devnet-build-1111:
	@$(MAKE) devnet-build-version VERSION=v1.11.1

devnet-build-1120:
	@$(MAKE) devnet-build-version VERSION=v1.12.0

_devnet-select-default-genesis:
	@set -e; \
	version="$${LUMERA_VERSION:-}"; \
	if [ -z "$$version" ]; then \
		if [ "$(DEVNET_BUILD_LUMERA)" = "1" ]; then \
			build_bin="$(BUILD_DIR)/lumerad"; \
			if [ -x "$$build_bin" ]; then \
				version="$$( "$$build_bin" version 2>/dev/null | grep -Eo 'v?[0-9]+\.[0-9]+\.[0-9]+([-+][0-9A-Za-z.-]+)?' | head -n1 || true )"; \
			fi; \
			if [ -z "$$version" ]; then \
				version="$$( git describe --tags --dirty 2>/dev/null | grep -Eo 'v?[0-9]+\.[0-9]+\.[0-9]+([-+][0-9A-Za-z.-]+)?' | head -n1 || true )"; \
			fi; \
		fi; \
	fi; \
	if [ -z "$$version" ]; then \
		bin_path="$(DEVNET_BIN_DIR_ABS)/lumerad"; \
		if [ -x "$$bin_path" ]; then \
			version="$$( "$$bin_path" version 2>/dev/null | grep -Eo 'v?[0-9]+\.[0-9]+\.[0-9]+([-+][0-9A-Za-z.-]+)?' | head -n1 || true )"; \
		fi; \
	fi; \
	case "$$version" in \
		v*|"") ;; \
		*) version="v$$version" ;; \
	esac; \
	cutover="$(EVM_CUTOVER_VERSION)"; \
	case "$$cutover" in \
		v*|"") ;; \
		*) cutover="v$$cutover" ;; \
	esac; \
	if [ -n "$$version" ] && printf '%s\n' "$$cutover" "$$version" | sort -V | head -n1 | grep -q "^$$cutover$$"; then \
		echo "$(DEFAULT_GENESIS_EVM_FILE)"; \
	else \
		echo "$(DEFAULT_GENESIS_FILE)"; \
	fi

devnet-reset:
	@echo "Resetting all validators (gentx and keys)..."
	@cd devnet && for i in $$(docker compose -f ${COMPOSE_FILE} config --services | grep '^supernova_validator_'); do \
		echo "Resetting $$i..."; \
		if docker compose -f ${COMPOSE_FILE} ps $$i | grep -q 'Up'; then \
			docker compose -f ${COMPOSE_FILE} exec -T $$i bash -c "\
			  rm -f /root/.lumera/config/genesis.json /root/.lumera/config/priv_validator_key.json"; \
			docker compose -f ${COMPOSE_FILE} restart $$i; \
		else \
			echo "Container $$i is not running. Starting and resetting..."; \
			docker compose -f ${COMPOSE_FILE} run --rm $$i bash -c "\
			  rm -f /root/.lumera/config/genesis.json /root/.lumera/config/priv_validator_key.json"; \
		fi \
	done
	
devnet-up:
	@if [ -f "${COMPOSE_FILE}" ]; then \
		echo "Starting devnet..."; \
		cd devnet && \
		START_MODE=auto docker compose up; \
	else \
		echo "Devnet not built yet. Please run 'make devnet-build' first."; \
		exit 1; \
	fi

devnet-up-detach:
	@if [ -f "${COMPOSE_FILE}" ]; then \
		cd devnet && \
		START_MODE=auto docker compose up -d; \
	else \
		echo "Devnet not built yet. Please run 'make devnet-build' first."; \
		exit 1; \
	fi

devnet-down:
	@if [ -f "${COMPOSE_FILE}" ]; then \
		echo "Stopping devnet..."; \
		cd devnet && \
	    docker compose down --remove-orphans; \
	else \
		echo "Devnet not built yet. Nothing to stop."; \
	fi

devnet-stop:
	@if [ -f "${COMPOSE_FILE}" ]; then \
		echo "Stopping devnet containers..."; \
		cd devnet && \
		docker compose stop; \
	else \
		echo "Devnet not built yet. Nothing to stop."; \
	fi

devnet-start:
	@if [ -f "${COMPOSE_FILE}" ]; then \
		echo "Starting devnet containers..."; \
		cd devnet && \
		START_MODE=run docker compose up; \
	else \
		echo "Devnet not built yet. Nothing to start."; \
	fi

devnet-clean:
	sudo rm -rf $(SHARED_DIR) $(VALIDATOR_DIRS) $(HERMES_SIMD_DIR) $(HERMES_ROUTER_DIR)
	rm -f devnet/docker-compose.yml
	@echo "Devnet docker shared & generated files cleaned up."

devnet-upgrade:
	@mkdir -p "${DEVNET_BIN_DIR}"; \
	if [ "$(DEVNET_BUILD_LUMERA)" = "1" ]; then \
		$(MAKE) build; \
		if [ ! -f "${BUILD_DIR}/lumerad" ]; then \
			echo "Cannot find lumerad binary [${BUILD_DIR}/lumerad]"; \
			exit 1; \
		fi; \
		cp -f ${BUILD_DIR}/lumerad "${DEVNET_BIN_DIR}" && \
		go get github.com/CosmWasm/wasmvm/$(WASMVM_VERSION) && \
		find $$(go env GOPATH)/pkg/mod/github.com/!cosm!wasm/wasmvm/$(WASMVM_VERSION) -name "libwasmvm.x86_64.so" -exec cp -f {} ${DEVNET_BIN_DIR}/libwasmvm.x86_64.so \; \
	else \
		echo "Using lumera binaries from ${DEVNET_BIN_DIR}..."; \
	fi; \
	echo "Stopping devnet containers..."; \
	docker compose -f ${COMPOSE_FILE} stop; \
	if [ ! -f "${DEVNET_BIN_DIR}/lumerad" ]; then \
		echo "${DEVNET_BIN_DIR}/lumerad binary not found..."; \
		exit 1; \
	fi; \
	if [ ! -f "${DEVNET_BIN_DIR}/libwasmvm.x86_64.so" ]; then \
		echo "${DEVNET_BIN_DIR}/libwasmvm.x86_64.so library not found..."; \
		exit 1; \
	fi; \
	$(MAKE) devnet-tests-build DEVNET_BIN_DIR="${DEVNET_BIN_DIR}"; \
	cp -f "${DEVNET_BIN_DIR}/lumerad" "${SHARED_RELEASE_DIR}/"; \
	cp -f "${DEVNET_BIN_DIR}/libwasmvm.x86_64.so" "${SHARED_RELEASE_DIR}/"; \
	cd devnet && \
	CONFIG_JSON="$${CONFIG_JSON:-$(DEFAULT_CONFIG_JSON)}" \
	VALIDATORS_JSON="$${VALIDATORS_JSON:-$(DEFAULT_VALIDATORS_JSON)}" \
	./scripts/configure.sh --bin-dir "${DEVNET_BIN_DIR}"

devnet-new:
	$(MAKE) devnet-down
	$(MAKE) devnet-clean
	$(MAKE) devnet-build-default

devnet-update-binaries:
	@if [ ! -f "${BUILD_DIR}/lumerad" ]; then \
		echo "Cannot find lumerad binary [${BUILD_DIR}/lumerad]"; \
		exit 1; \
	fi; \
	if [ ! -f "${BUILD_DIR}/libwasmvm.x86_64.so" ]; then \
		go get github.com/CosmWasm/wasmvm/$(WASMVM_VERSION) && \
		WASMVM_SO="$$(find $$(go env GOPATH)/pkg/mod/github.com/!cosm!wasm/wasmvm/$(WASMVM_VERSION) -name "libwasmvm.x86_64.so" -print -quit)" && \
		if [ -z "$$WASMVM_SO" ]; then \
			echo "Unable to locate libwasmvm.x86_64.so in GOPATH"; \
			exit 1; \
		fi; \
		cp -f "$$WASMVM_SO" ${BUILD_DIR}/libwasmvm.x86_64.so; \
	fi; \
	release_name="$(DEVNET_UPGRADE_RELEASE)"; \
	if [ "$$release_name" = "auto" ]; then \
		release_name="$$( "${BUILD_DIR}/lumerad" version 2>/dev/null | grep -Eo 'v?[0-9]+\.[0-9]+\.[0-9]+([-+][0-9A-Za-z.-]+)?' | head -n1 || true )"; \
		if [ -z "$$release_name" ]; then \
			echo "Unable to auto-detect lumerad version from ${BUILD_DIR}/lumerad"; \
			exit 1; \
		fi; \
	fi; \
	case "$$release_name" in \
		v*) ;; \
		*) release_name="v$$release_name" ;; \
	esac; \
	echo "Using release $$release_name"; \
	./devnet/scripts/upgrade-binaries.sh "${BUILD_DIR}" "$$release_name"

devnet-update-binaries-default:
	@release_name="$(DEVNET_UPGRADE_RELEASE)"; \
	if [ "$$release_name" = "auto" ]; then \
		if [ ! -x "${DEVNET_BIN_DIR}/lumerad" ]; then \
			echo "Cannot find executable ${DEVNET_BIN_DIR}/lumerad for auto version detection"; \
			exit 1; \
		fi; \
		release_name="$$( "${DEVNET_BIN_DIR}/lumerad" version 2>/dev/null | grep -Eo 'v?[0-9]+\.[0-9]+\.[0-9]+([-+][0-9A-Za-z.-]+)?' | head -n1 || true )"; \
		if [ -z "$$release_name" ]; then \
			echo "Unable to auto-detect lumerad version from ${DEVNET_BIN_DIR}/lumerad"; \
			exit 1; \
		fi; \
	fi; \
	case "$$release_name" in \
		v*) ;; \
		*) release_name="v$$release_name" ;; \
	esac; \
	echo "Using release $$release_name"; \
	./devnet/scripts/upgrade-binaries.sh "${DEVNET_BIN_DIR}" "$$release_name"

devnet-refresh-bin:
	@mkdir -p "${DEVNET_BIN_DIR}"; \
	$(MAKE) build; \
	if [ ! -f "${BUILD_DIR}/lumerad" ]; then \
		echo "Cannot find lumerad binary [${BUILD_DIR}/lumerad]"; \
		exit 1; \
	fi; \
	cp -f "${BUILD_DIR}/lumerad" "${DEVNET_BIN_DIR}/lumerad"; \
	if [ -f "${BUILD_DIR}/libwasmvm.x86_64.so" ]; then \
		cp -f "${BUILD_DIR}/libwasmvm.x86_64.so" "${DEVNET_BIN_DIR}/libwasmvm.x86_64.so"; \
	else \
		go get github.com/CosmWasm/wasmvm/$(WASMVM_VERSION) && \
		WASMVM_SO="$$(find $$(go env GOPATH)/pkg/mod/github.com/!cosm!wasm/wasmvm/$(WASMVM_VERSION) -name "libwasmvm.x86_64.so" -print -quit)" && \
		if [ -z "$$WASMVM_SO" ]; then \
			echo "Unable to locate libwasmvm.x86_64.so in GOPATH"; \
			exit 1; \
		fi; \
		cp -f "$$WASMVM_SO" "${DEVNET_BIN_DIR}/libwasmvm.x86_64.so"; \
	fi; \
	chmod +x "${DEVNET_BIN_DIR}/lumerad"; \
	echo "Refreshed ${DEVNET_BIN_DIR} from current repo build."

# Download pre-built binaries for a specific lumera version from GitHub releases.
# Usage: make devnet-download-binaries VERSION=v1.12.0
devnet-download-binaries:
	@if [ -z "$(VERSION)" ]; then \
		echo "Usage: make devnet-download-binaries VERSION=<lumera-version>"; \
		echo "  e.g. make devnet-download-binaries VERSION=v1.12.0"; \
		exit 1; \
	fi
	@./devnet/scripts/download-binaries.sh "$(VERSION)"

devnet-update-scripts:
	@if [ ! -f "$(COMPOSE_FILE)" ]; then \
		echo "Missing $(COMPOSE_FILE); run 'make devnet-build' first."; \
		exit 1; \
	fi
	@services="$$(docker compose -f $(COMPOSE_FILE) ps --services)"; \
	common_scripts="common.sh account-registry.sh start.sh stop.sh restart.sh lumera-helper.sh validator-setup.sh supernode-setup.sh lumera-uploader-setup.sh test-accounts-setup.sh"; \
	migration_scripts="evmigration-common.sh migrate-account.sh migrate-multisig.sh migrate-validator.sh"; \
	updated=0; \
	for svc in $$services; do \
		container="$$(docker compose -f $(COMPOSE_FILE) ps -q $$svc)"; \
		if [ -z "$$container" ]; then \
			echo "Skipping service $$svc (not running)"; \
			continue; \
		fi; \
		if [ "$$svc" = "hermes" ]; then \
			for script_path in devnet/hermes/scripts/*.sh; do \
				[ -f "$$script_path" ] || continue; \
				script="$$(basename "$$script_path")"; \
				echo "Updating $$script in container $$container (service $$svc)"; \
				docker cp "$$script_path" "$$container:/root/scripts/$${script}"; \
				docker exec "$$container" chmod 0755 "/root/scripts/$${script}"; \
				updated=1; \
			done; \
		else \
			for script in $$common_scripts; do \
				host_script="devnet/scripts/$${script}"; \
				if [ ! -f "$$host_script" ]; then \
					echo "Warning: $$host_script not found; skipping."; \
					continue; \
				fi; \
				echo "Updating $$script in container $$container (service $$svc)"; \
				docker cp "$$host_script" "$$container:/root/scripts/$${script}"; \
				docker exec "$$container" chmod 0755 "/root/scripts/$${script}"; \
				updated=1; \
			done; \
			docker exec "$$container" mkdir -p /root/scripts/migration; \
			for script in $$migration_scripts; do \
				host_script="scripts/$${script}"; \
				if [ ! -f "$$host_script" ]; then \
					echo "Warning: $$host_script not found; skipping."; \
					continue; \
				fi; \
				echo "Updating migration/$$script in container $$container (service $$svc)"; \
				docker cp "$$host_script" "$$container:/root/scripts/migration/$${script}"; \
				docker exec "$$container" chmod 0755 "/root/scripts/migration/$${script}"; \
				updated=1; \
			done; \
		fi; \
	done; \
	if [ "$$updated" -eq 0 ]; then \
		echo "No containers were updated. Ensure the devnet is running."; \
	fi

.PHONY: devnet-new-1120
.PHONY: devnet-upgrade-1110 devnet-upgrade-1111 devnet-upgrade-1120 devnet-upgrade-1201
.PHONY: devnet-evm-upgrade devnet-upgrade-1202

# Upgrade a running devnet to a pre-downloaded lumera version.
# Expects devnet/bin-<VERSION>/ to already contain the binaries.
# Usage: make devnet-upgrade-version VERSION=v1.12.0
devnet-upgrade-version: _check-devnet-version-bin
	@cd devnet/scripts && ./upgrade.sh $(VERSION) auto-height ../bin-$(VERSION)

# Full reset + rebuild + start for a specific pre-downloaded version.
# Stops running containers, wipes devnet state, rebuilds from
# devnet/bin-<VERSION>/, and starts the stack attached.
# Usage: make devnet-new-version VERSION=v1.12.0
devnet-new-version:
	@if [ -z "$(VERSION)" ]; then \
		echo "VERSION is required. Usage: make devnet-new-version VERSION=v1.12.0"; \
		exit 1; \
	fi
	$(MAKE) devnet-down
	$(MAKE) devnet-clean
	$(MAKE) devnet-build-version VERSION=$(VERSION)
	sleep 10
	$(MAKE) devnet-up

devnet-upgrade-1110:
	@$(MAKE) devnet-upgrade-version VERSION=v1.11.0

devnet-upgrade-1111:
	@$(MAKE) devnet-upgrade-version VERSION=v1.11.1

devnet-upgrade-1120:
	@$(MAKE) devnet-upgrade-version VERSION=v1.12.0

# Special case: upgrade to the locally-built version (devnet/bin, not
# devnet/bin-<VERSION>). Stays separate from devnet-upgrade-version because
# the binary source differs (local repo build vs pre-downloaded release).
devnet-upgrade-1201:
	@$(MAKE) devnet-refresh-bin
	@cd devnet/scripts && ./upgrade.sh v1.20.1 auto-height ../bin

# v1.20.2 — same locally-built-binary pattern as devnet-upgrade-1201. The
# on-chain plan remains v1.20.2, but the superseding binary must report v1.20.3.
# Drives the coordinated
# governance halt + binary swap, which is MANDATORY for this upgrade: v1.20.2
# changes evmigration DeliverTx outcomes (PrevSupernodeAccounts append vs
# rewrite, canonical ownership resolution, Everlight SNDistState move), so a
# rolling node-by-node restart would fork the network.
#
# Serves BOTH rehearsal shapes from one target, since the handler is
# state-driven rather than chain-id-driven:
#   testnet-shaped   1.20.1 -> 1.20.2   migrations only (EVM already present)
#   mainnet-shaped   1.12.0 -> 1.20.2   full EVM bring-up + add-only store mount
devnet-upgrade-1202:
	@$(MAKE) devnet-refresh-bin
	@cd devnet/scripts && ./upgrade.sh v1.20.2 auto-height ../bin v1.20.3

devnet-new-1120:
	@$(MAKE) devnet-new-version VERSION=v1.12.0

DEVNET_EVM_UPGRADE_LOG ?= devnet/logs/evm-upgrade-$(shell date +%Y%m%d-%H%M).log

devnet-evm-upgrade:
	@mkdir -p devnet/logs
	@echo "Logging to $(DEVNET_EVM_UPGRADE_LOG)"
	@bash -c 'set -euo pipefail; { \
	BASE_VERSION=v1.12.0; \
	EVM_VERSION=v1.20.2; \
	echo "==> Stage: install $$BASE_VERSION devnet"; \
	if ! $(MAKE) devnet-down; then \
		echo "ERROR: stage install $$BASE_VERSION devnet failed during devnet-down" >&2; \
		exit 1; \
	fi; \
	if ! $(MAKE) devnet-clean; then \
		echo "ERROR: stage install $$BASE_VERSION devnet failed during devnet-clean" >&2; \
		exit 1; \
	fi; \
	if ! $(MAKE) devnet-build-version VERSION=$$BASE_VERSION; then \
		echo "ERROR: stage install $$BASE_VERSION devnet failed during devnet-build-version" >&2; \
		exit 1; \
	fi; \
	sleep 10; \
	if ! $(MAKE) devnet-up-detach; then \
		echo "ERROR: stage install $$BASE_VERSION devnet failed during devnet-up-detach" >&2; \
		exit 1; \
	fi; \
	echo "==> Stage: wait for height 40"; \
	if ! ./devnet/scripts/wait-for-height.sh 40; then \
		echo "ERROR: stage wait for height 40 failed" >&2; \
		exit 1; \
	fi; \
	echo "==> Stage: devnet-evmigrationp-prepare"; \
	if ! $(MAKE) devnet-evmigrationp-prepare; then \
		echo "ERROR: stage devnet-evmigrationp-prepare failed" >&2; \
		exit 1; \
	fi; \
	current_height="$$(docker compose -f $(COMPOSE_FILE) exec -T supernova_validator_1 \
		lumerad status 2>/dev/null | jq -r ".sync_info.latest_block_height // empty" 2>/dev/null || true)"; \
	if ! echo "$$current_height" | grep -Eq "^[0-9]+$$"; then \
		echo "ERROR: stage post-prepare wait failed to determine current chain height" >&2; \
		exit 1; \
	fi; \
	target_height=$$((current_height + 5)); \
	echo "==> Stage: wait for height $${target_height}"; \
	if ! ./devnet/scripts/wait-for-height.sh "$$target_height"; then \
		echo "ERROR: stage post-prepare wait failed while waiting for height $${target_height}" >&2; \
		exit 1; \
	fi; \
	echo "==> Stage: upgrade to $$EVM_VERSION"; \
	if ! $(MAKE) devnet-upgrade-1202; then \
		echo "ERROR: stage upgrade to $$EVM_VERSION failed" >&2; \
		exit 1; \
	fi; \
	current_height="$$(docker compose -f $(COMPOSE_FILE) exec -T supernova_validator_1 \
		lumerad status 2>/dev/null | jq -r ".sync_info.latest_block_height // empty" 2>/dev/null || true)"; \
	if ! echo "$$current_height" | grep -Eq "^[0-9]+$$"; then \
		echo "ERROR: stage post-upgrade wait failed to determine current chain height" >&2; \
		exit 1; \
	fi; \
	target_height=$$((current_height + 10)); \
	echo "==> Stage: wait for height $${target_height} (post-upgrade settle)"; \
	if ! ./devnet/scripts/wait-for-height.sh "$$target_height"; then \
		echo "ERROR: stage post-upgrade wait failed while waiting for height $${target_height}" >&2; \
		exit 1; \
	fi; \
	echo "==> Stage: devnet-evmigrationp-estimate"; \
	if ! $(MAKE) devnet-evmigrationp-estimate; then \
		echo "ERROR: stage devnet-evmigrationp-estimate failed" >&2; \
		exit 1; \
	fi; \
	echo "==> Stage: devnet-evmigrationp-migrate-all"; \
	if ! $(MAKE) devnet-evmigrationp-migrate-all; then \
		echo "ERROR: stage devnet-evmigrationp-migrate-all failed" >&2; \
		exit 1; \
	fi; \
	echo "==> Stage: devnet-evmigrationp-verify"; \
	if ! $(MAKE) devnet-evmigrationp-verify; then \
		echo "ERROR: stage devnet-evmigrationp-verify failed" >&2; \
		exit 1; \
	fi; \
	echo "devnet-evm-upgrade completed successfully."; \
	} 2>&1 | tee "$(DEVNET_EVM_UPGRADE_LOG)"'

devnet-deploy-tar:
	# Ensure required files exist from previous build
	@if [ ! -f "devnet/docker-compose.yml" ] || [ ! -f "devnet/bin/lumerad" ] || [ ! -f "devnet/bin/libwasmvm.x86_64.so" ]; then \
		echo "Please run 'make devnet-build' first to generate required files."; \
		exit 1; \
	fi
	# Optionally include external_genesis.json if available
	@if [ -f "$(EXTERNAL_GENESIS_FILE)" ]; then \
		cp -f "$(EXTERNAL_GENESIS_FILE)" devnet/external_genesis.json; \
	fi

	if [ -n "$(EXTERNAL_CLAIMS_FILE)" ] && [ -f "$(EXTERNAL_CLAIMS_FILE)" ]; then \
		cp -f "${EXTERNAL_CLAIMS_FILE}" devnet/claims.csv; \
	else \
		echo "No external claims file provided or file not found."; \
		exit 1; \
	fi
	# Create the tar archive
	tar -czf devnet-deploy.tar.gz \
		-C devnet dockerfile \
		docker-compose.yml \
		primary-validator.sh \
		secondary-validator.sh \
		lumerad \
		libwasmvm.x86_64.so \
		devnet-deploy.sh \
		claims.csv \
		$(if $(shell [ -f "$(EXTERNAL_GENESIS_FILE)" ] && echo 1),external_genesis.json)

	@if [ -f "devnet/external_genesis.json" ]; then \
		rm devnet/external_genesis.json; \
	fi
	@echo "Created devnet-deploy.tar.gz with the required files."

##### EVM Migration test targets #############################
#
# Run the evmigration test tool inside each devnet validator container
# via docker compose exec.
#
# Inside containers:
#   binary   = /shared/release/tests_evmigration
#   lumerad  = /shared/release/lumerad  (symlinked to PATH or used via -bin)
#   home     = /root/.lumera
#   RPC      = tcp://localhost:26657    (each container exposes its own node)
#   accounts = /shared/status/<moniker>/evmigration-accounts.json
#              (unique per validator to avoid cross-validator key/account reuse)
#   names    = evm_test_<validator_tag>_<idx> / evm_testex_<validator_tag>_<idx>
#              (validator tag is auto-derived by tests_evmigration from local validator/funder key name)

EVMIGRATION_CHAIN_ID ?= lumera-devnet-1
EVMIGRATION_NUM_ACCOUNTS ?= 7
EVMIGRATION_NUM_EXTRA ?= 7
# Cross-process serialization for cascade action creation. When non-empty,
# tests_evmigration takes an exclusive flock on this path before each
# request-action call and waits one block before releasing - preventing the
# parallel-prepare run from landing multiple MsgRequestAction txs in the same
# block, which exposes a known supernode race on MsgFinalizeAction sequences.
# Set to "" (empty) to disable. The path must live on a volume shared by all
# validator containers; /shared/status/ is bind-mounted from $(DEVNET_DIR)/shared.
EVMIGRATION_ACTION_LOCK_FILE ?= /shared/status/action-create.lock
# Container-internal paths (the /shared volume is mounted from $(DEVNET_DIR)/shared).
_EVMIGRATION_BIN_CONTAINER  := /shared/release/tests_evmigration
_EVMIGRATION_LUMERAD_CONTAINER := /shared/release/lumerad
_EVMIGRATION_BIN_HOST := $(DEVNET_BIN_DIR_ABS)/tests_evmigration
_EVMIGRATION_BIN_SHARED_HOST := $(SHARED_RELEASE_DIR)/tests_evmigration

# Discover running validator services from the compose file.
_EVMIGRATION_SERVICES = $(shell docker compose -f $(COMPOSE_FILE) ps --services 2>/dev/null | grep '^supernova_validator_' | sort)

# Common flags passed to the binary inside the container.
_evmigration_common_container = \
	-bin="$(_EVMIGRATION_LUMERAD_CONTAINER)" \
	-chain-id="$(EVMIGRATION_CHAIN_ID)" \
	-home="/root/.lumera" \
	-rpc="tcp://localhost:26657"

define _run_evmigration_in_containers
	@if [ ! -f "$(COMPOSE_FILE)" ]; then \
		echo "docker-compose.yml not found; run 'make devnet-build' first"; \
		exit 1; \
	fi; \
	services="$(_EVMIGRATION_SERVICES)"; \
	if [ -z "$$services" ]; then \
		echo "No running supernova_validator_* services found; is the devnet up?"; \
		exit 1; \
	fi; \
	for svc in $$services; do \
		accounts_path="/shared/status/$${svc}/evmigration-accounts.json"; \
		echo "=== $(1) on $${svc} ==="; \
		echo "    accounts file: $${accounts_path}"; \
		docker compose -f $(COMPOSE_FILE) exec -T "$${svc}" \
			"$(_EVMIGRATION_BIN_CONTAINER)" \
			$(_evmigration_common_container) \
			-accounts="$${accounts_path}" \
			-mode="$(1)" \
			$(2) || exit 1; \
	done
endef

devnet-evmigration-sync-bin:
	@src="$(_EVMIGRATION_BIN_HOST)"; \
	dst="$(_EVMIGRATION_BIN_SHARED_HOST)"; \
	if [ ! -f "$$src" ] || find devnet/tests/evmigration -type f -newer "$$src" | grep -q .; then \
		echo "building fresh tests_evmigration binary..."; \
		mkdir -p "$(DEVNET_BIN_DIR_ABS)"; \
		cd devnet && $(GO) build -o "$$src" ./tests/evmigration; \
	fi; \
	mkdir -p "$$(dirname "$$dst")"; \
	if [ -f "$$dst" ] && cmp -s "$$src" "$$dst"; then \
		echo "tests_evmigration binary is up to date in shared/release"; \
	else \
		cp -f "$$src" "$$dst"; \
		chmod +x "$$dst"; \
		echo "synced tests_evmigration to $$dst"; \
	fi

devnet-evmigration-prepare: devnet-evmigration-sync-bin
	$(call _run_evmigration_in_containers,prepare,-num-accounts=$(EVMIGRATION_NUM_ACCOUNTS) -num-extra=$(EVMIGRATION_NUM_EXTRA))

devnet-evmigration-estimate: devnet-evmigration-sync-bin
	$(call _run_evmigration_in_containers,estimate)

devnet-evmigration-migrate: devnet-evmigration-sync-bin
	$(call _run_evmigration_in_containers,migrate)

devnet-evmigration-migrate-validator: devnet-evmigration-sync-bin
	$(call _run_evmigration_in_containers,migrate-validator)

devnet-evmigration-verify: devnet-evmigration-sync-bin
	$(call _run_evmigration_in_containers,verify)

devnet-evmigration-cleanup: devnet-evmigration-sync-bin
	$(call _run_evmigration_in_containers,cleanup)

##### Parallel EVM Migration targets ##########################
#
# Same as the sequential targets above, but all validators run
# concurrently. Output is prefixed with the service name.

define _run_evmigration_in_containers_parallel
	@if [ ! -f "$(COMPOSE_FILE)" ]; then \
		echo "docker-compose.yml not found; run 'make devnet-build' first"; \
		exit 1; \
	fi; \
	services="$(_EVMIGRATION_SERVICES)"; \
	if [ -z "$$services" ]; then \
		echo "No running supernova_validator_* services found; is the devnet up?"; \
		exit 1; \
	fi; \
	tmpdir="$$(mktemp -d)"; \
	pids=""; \
	for svc in $$services; do \
		accounts_path="/shared/status/$${svc}/evmigration-accounts.json"; \
		echo "=== $(1) on $${svc} (parallel) ==="; \
		( docker compose -f $(COMPOSE_FILE) exec -T "$${svc}" \
			"$(_EVMIGRATION_BIN_CONTAINER)" \
			$(_evmigration_common_container) \
			-accounts="$${accounts_path}" \
			-mode="$(1)" \
			$(2) > "$${tmpdir}/$${svc}.out" 2>&1 ; \
		  echo $$? > "$${tmpdir}/$${svc}.rc" \
		) & \
		pids="$$pids $$!"; \
	done; \
	wait $$pids; \
	failed=0; \
	for svc in $$services; do \
		rc="$$(cat "$${tmpdir}/$${svc}.rc" 2>/dev/null || echo 1)"; \
		echo "=== output from $${svc} (exit $$rc) ==="; \
		sed "s/^/[$${svc}] /" < "$${tmpdir}/$${svc}.out" 2>/dev/null || true; \
		if [ "$$rc" != "0" ]; then \
			echo "FAIL: $(1) on $${svc} exited with code $$rc"; \
			failed=1; \
		fi; \
	done; \
	rm -rf "$$tmpdir"; \
	if [ "$$failed" = "1" ]; then exit 1; fi
endef

devnet-evmigrationp-prepare: devnet-evmigration-sync-bin
	$(call _run_evmigration_in_containers_parallel,prepare,-num-accounts=$(EVMIGRATION_NUM_ACCOUNTS) -num-extra=$(EVMIGRATION_NUM_EXTRA) -action-lock-file=$(EVMIGRATION_ACTION_LOCK_FILE))

devnet-evmigrationp-estimate: devnet-evmigration-sync-bin
	$(call _run_evmigration_in_containers_parallel,estimate)

devnet-evmigrationp-migrate: devnet-evmigration-sync-bin
	$(call _run_evmigration_in_containers_parallel,migrate)

devnet-evmigrationp-migrate-validator: devnet-evmigration-sync-bin
	$(call _run_evmigration_in_containers_parallel,migrate-validator)

devnet-evmigrationp-migrate-all: devnet-evmigration-sync-bin
	$(call _run_evmigration_in_containers_parallel,migrate-all)

devnet-evmigrationp-verify: devnet-evmigration-sync-bin
	$(call _run_evmigration_in_containers_parallel,verify)

devnet-evmigrationp-cleanup: devnet-evmigration-sync-bin
	$(call _run_evmigration_in_containers_parallel,cleanup)

devnet-tests-everlight:
	@echo "Running Everlight devnet tests..."
	@bash devnet/tests/everlight/everlight_test.sh

devnet-tests-lep6:
	@echo "Running LEP-6 storage-truth devnet tests..."
	@COMPOSE_FILE="$${COMPOSE_FILE:-devnet/docker-compose.yml}" \
		CHAIN_ID="$${CHAIN_ID:-lumera-devnet-1}" \
		bash devnet/tests/lep6/lep6_test.sh

devnet-new-no-hermes:
	$(MAKE) devnet-down
	$(MAKE) devnet-clean
	$(MAKE) devnet-build-default CONFIG_JSON=config/config-no-hermes.json