feat: docker compose (#64)

* feat: create dockerfile for sidecar

* feat: add dockerfile for main app

* feat: add docker compose

* fix: fix app dockerfile and add entrypoint

* fix: running docker compose

* feat: new github ci workflow, testing and debuging dockercompose

* fix: fixing various docker networking issues

* fix: docker compose running locally

* chore: remove debug system prune

---------

Co-authored-by: Matthew Sevey <[email protected]>

Author: MSevey

.github/workflows/docker-build.yml

@@ -0,0 +1,69 @@
+name: Build and Push Docker Images
+
+on:
+  pull_request:
+  push:
+    branches: [ main ]
+    tags: [ 'v*' ]
+
+env:
+  REGISTRY: ghcr.io
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      matrix:
+        include:
+          - name: arda-pocd
+            dockerfile: ./Dockerfile
+          - name: tx-sidecar
+            dockerfile: ./cmd/tx-sidecar/Dockerfile
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Log in to Container Registry
+      uses: docker/login-action@v3
+      with:
+        registry: ${{ env.REGISTRY }}
+        username: ${{ github.actor }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Extract metadata
+      id: meta
+      uses: docker/metadata-action@v5
+      with:
+        images: ${{ env.REGISTRY }}/${{ github.repository }}/${{ matrix.name }}
+        tags: |
+          type=ref,event=branch
+          type=ref,event=pr
+          type=semver,pattern={{version}}
+          type=semver,pattern={{major}}.{{minor}}
+          type=semver,pattern={{major}}
+          type=sha,prefix=sha-
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Build and push Docker image
+      id: build-and-push
+      uses: docker/build-push-action@v5
+      with:
+        context: .
+        file: ${{ matrix.dockerfile }}
+        push: true
+        tags: ${{ steps.meta.outputs.tags }}
+        labels: ${{ steps.meta.outputs.labels }}
+        platforms: linux/amd64,linux/arm64
+        cache-from: type=gha
+        cache-to: type=gha,mode=max
+
+    - name: Output image digest
+      run: |
+        echo "${{ matrix.name }} image digest: ${{ steps.build-and-push.outputs.digest }}"
+      

.github/workflows/release.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
@@ -46,7 +46,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Publish the Release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
         if: ${{ steps.vars.outputs.should_release == 'true' }}
         with:
           tag_name: ${{ steps.vars.outputs.tag_name }}

Dockerfile

@@ -0,0 +1,40 @@
+###############  Stage 1 – build  ###############
+FROM golang:1.24-alpine AS builder
+ARG IGNITE_VERSION=v28.10.0
+
+RUN apk add --no-cache build-base git curl bash
+RUN curl -L "https://get.ignite.com/cli@${IGNITE_VERSION}!" | bash
+
+WORKDIR /src
+COPY . .
+
+# put ./build on the PATH so `which` can see the binary
+ENV PATH="/src/build:${PATH}"
+
+RUN ignite chain build && ignite chain init --home .arda-poc
+
+# figure out where the node binary is *at runtime* and copy it out
+RUN BIN=$(which arda-pocd 2>/dev/null || true)  \
+ && if [ -z "$BIN" ]; then echo "arda-pocd not found on PATH"; exit 1; fi \
+ && install -Dm755 "$BIN" /out/arda-pocd \
+ && cp -r .arda-poc /out/.arda-poc-template
+
+###############  Stage 2 – runtime ###############
+FROM alpine:3.19
+RUN apk update && apk add --no-cache bash curl
+
+# binary + template only
+COPY --from=builder /out/arda-pocd          /usr/local/bin/arda-pocd
+COPY --from=builder /out/.arda-poc-template /template/.arda-poc
+
+# copy in entrypoint script
+COPY scripts/entrypoint.sh /usr/local/bin/entrypoint.sh
+RUN chmod +x /usr/local/bin/entrypoint.sh
+
+# declare persistent state location
+VOLUME ["/data"]
+ENV ARDA_HOME=/data/.arda-poc
+WORKDIR /data
+
+EXPOSE 26657 1317 9090 4500
+ENTRYPOINT ["/usr/local/bin/entrypoint.sh"]

Makefile

@@ -170,3 +170,34 @@ prod:
 	cp config.toml ~/.$(APPNAME)/config/config.toml
 	$(APPNAME)d start
 .PHONY: prod
+
+################
+###  Docker  ###
+################
+
+# Individual build commands
+docker-build-main:
+	@echo "--> Building arda-pocd docker image"
+	@docker build -t arda-pocd-ignite -f Dockerfile .
+.PHONY: docker-build-main
+
+docker-build-tx-sidecar:
+	@echo "--> Building tx-sidecar docker image"
+	@docker build -t tx-sidecar-compose -f cmd/tx-sidecar/Dockerfile .
+.PHONY: docker-build-tx-sidecar
+
+# Docker Compose commands
+dc-up:
+	@echo "--> Starting docker-compose services"
+	@docker-compose up -d --build
+.PHONY: dc-up
+
+dc-down:
+	@echo "--> Stopping docker-compose services"
+	@docker-compose down
+.PHONY: dc-down
+
+dc-logs:
+	@echo "--> Tailing logs for all services"
+	@docker-compose logs -f
+.PHONY: dc-logs

cmd/tx-sidecar/Dockerfile

@@ -0,0 +1,36 @@
+
+# Stage 1: Build the application
+FROM golang:1.24-alpine AS builder
+
+WORKDIR /src
+
+# Copy go.mod and go.sum files
+COPY go.mod go.sum ./
+RUN go mod download
+
+# Copy the rest of the application source code
+COPY . .
+
+# Build the application
+# We are building from the root of the project, so we need to specify the path to the main package
+RUN CGO_ENABLED=0 GOOS=linux go build -o /app/tx-sidecar ./cmd/tx-sidecar
+
+# Stage 2: Create the final image
+FROM alpine:3.19
+
+WORKDIR /app
+
+# Copy the built binary from the builder stage
+COPY --from=builder /app/tx-sidecar .
+
+# The swagger documentation seems to be served by the application, so we copy it as well.
+COPY ./cmd/tx-sidecar/docs ./docs
+COPY config.yml .
+
+VOLUME /app/local_data
+
+# Expose the port the application runs on
+EXPOSE 8080
+
+# Run the application
+ENTRYPOINT ["./tx-sidecar"] 

cmd/tx-sidecar/main.go

@@ -39,6 +39,21 @@ import (
 	"github.com/joho/godotenv"
 )
 
+// getEnv is a helper function to read an environment variable or return a fallback value.
+func getEnv(key, fallback string) string {
+	if value, ok := os.LookupEnv(key); ok {
+		return value
+	}
+	return fallback
+}
+
+var (
+	blockchainRestAPIURL = getEnv("BLOCKCHAIN_REST_API_URL", "http://localhost:1317")
+	grpcAddr             = getEnv("GRPC_ADDR", "localhost:9090")
+	nodeRPCURL           = getEnv("NODE_RPC_URL", "http://localhost:26657")
+	faucetURL            = getEnv("FAUCET_URL", "http://localhost:4500")
+)
+
 func init() {
 	zlog.Logger = zlog.Output(zerolog.ConsoleWriter{Out: os.Stdout})
 }
@@ -257,8 +272,9 @@ func NewServer(clientCtx client.Context, grpcAddr string) (*Server, error) {
 	// Ensure that the faucet account from config exists in the keyring.
 	if _, err := s.clientCtx.Keyring.Key(s.faucetName); err != nil {
 		zlog.Warn().Msgf("faucet user '%s' from config.yml not found in keyring: %v", s.faucetName, err)
+	} else {
+		zlog.Info().Msgf("Faucet user '%s' found in keyring.", s.faucetName)
 	}
-	zlog.Info().Msgf("Using '%s' as the faucet account.", s.faucetName)
 
 	// Ensure faucet user has the 'bank' role.
 	if faucetUserData, ok := s.users[s.faucetName]; ok {
@@ -329,7 +345,7 @@ func (s *Server) adminLoginHandler(c *fiber.Ctx) error {
 
 // passthroughGET proxies a GET request to the blockchain REST API and returns the response as-is.
 func passthroughGET(path string, c *fiber.Ctx) error {
-	baseURL := "http://localhost:1317"
+	baseURL := blockchainRestAPIURL
 	// Compose the full URL
 	url := baseURL + path
 	resp, err := http.Get(url)
@@ -391,45 +407,40 @@ func getMortgagesPassthrough(c *fiber.Ctx) error {
 // isBlockchainRunning checks if both the blockchain REST API and gRPC API are accessible
 func isBlockchainRunning() bool {
 	// Check REST API
-	baseURL := os.Getenv("BLOCKCHAIN_REST_API_URL")
-	if baseURL == "" {
-		baseURL = "http://localhost:1317"
-	}
+	baseURL := blockchainRestAPIURL
 	restURL := baseURL + "/cosmos/base/tendermint/v1beta1/node_info"
+	zlog.Info().Msgf("Checking blockchain REST API at %s", restURL)
 
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
+	restCtx, restCancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer restCancel()
 
-	req, err := http.NewRequestWithContext(ctx, "GET", restURL, nil)
+	req, err := http.NewRequestWithContext(restCtx, "GET", restURL, nil)
 	if err != nil {
+		zlog.Error().Msgf("Blockchain not ready: failed to create request for REST API: %v", err)
 		return false
 	}
 
 	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
+		zlog.Error().Msgf("Blockchain not ready: failed to make request to REST API: %v", err)
 		return false
 	}
 	defer resp.Body.Close()
 
-	if resp.StatusCode != 200 {
+	if resp.StatusCode != http.StatusOK {
+		zlog.Error().Msgf("Blockchain not ready: REST API returned status %d", resp.StatusCode)
 		return false
 	}
 
 	// Check gRPC API
-	grpcHost := "localhost"
-	if strings.Contains(baseURL, "://") {
-		if u, err := url.Parse(baseURL); err == nil {
-			grpcHost = u.Hostname()
-		}
-	}
-	grpcAddr := fmt.Sprintf("%s:9090", grpcHost)
+	zlog.Info().Msgf("Checking blockchain gRPC API at %s", grpcAddr)
 
-	// Try to establish a gRPC connection
-	grpcConn, err := grpc.Dial(grpcAddr, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithBlock(), grpc.WithTimeout(5*time.Second))
+	conn, err := grpc.NewClient(grpcAddr, grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithBlock())
 	if err != nil {
+		zlog.Error().Msgf("Blockchain not ready: NewClient failed for gRPC: %v", err)
 		return false
 	}
-	defer grpcConn.Close()
+	defer conn.Close()
 
 	return true
 }
@@ -464,8 +475,12 @@ func main() {
 		zlog.Fatal().Msgf("Failed to parse node URI: %v", err)
 	}
 	host := strings.Split(parsedURL.Host, ":")[0]
-	grpcAddr := fmt.Sprintf("%s:9090", host)
+	clientCtxGrpcAddr := fmt.Sprintf("%s:9090", host)
 
+	if clientCtxGrpcAddr != grpcAddr {
+		zlog.Warn().Msgf("Using grpc addresses don't match: %s != %s", clientCtxGrpcAddr, grpcAddr)
+	}
+	// Use the client context's grpc address if it's set, otherwise use the default.
 	server, err := NewServer(clientCtx, grpcAddr)
 	if err != nil {
 		zlog.Fatal().Msgf("Failed to create server: %v", err)
@@ -557,3 +572,4 @@ func main() {
 		zlog.Fatal().Msgf("Failed to start server: %v", err)
 	}
 }
+

config.toml

@@ -16,7 +16,7 @@ version = "0.38.17"
 
 # TCP or UNIX socket address of the ABCI application,
 # or the name of an ABCI application compiled in with the CometBFT binary
-proxy_app = "tcp://127.0.0.1:26658"
+proxy_app = "tcp://0.0.0.0:26658"
 
 # A custom human readable name for this node
 moniker = "ERES Validator"
@@ -195,7 +195,7 @@ tls_cert_file = ""
 tls_key_file = ""
 
 # pprof listen address (https://golang.org/pkg/net/http/pprof)
-pprof_laddr = "localhost:6060"
+pprof_laddr = "0.0.0.0:6060"
 
 #######################################################
 ###           P2P Configuration Options             ###

docker-compose.yml

@@ -0,0 +1,38 @@
+services:
+  arda:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    image: arda-pocd
+    ports:
+      - "26657:26657"   # Tendermint RPC
+      - "1317:1317"     # REST API
+      - "9090:9090"     # gRPC
+      - "4500:4500"     # Faucet
+    volumes:
+      - arda_state:/data            # <-- named volume, not host bind
+    environment:
+      - ARDA_HOME=/data/.arda-poc
+
+  sidecar:
+    build:
+      context: .
+      dockerfile: cmd/tx-sidecar/Dockerfile
+    image: tx-sidecar-compose
+    volumes:
+      - arda_state:/data            # share chain state
+      - sidecar_data:/app/local_data         # own DB
+    ports:
+      - "8080:8080"
+    environment:
+      - BLOCKCHAIN_REST_API_URL=http://arda:1317
+      - GRPC_ADDR=arda:9090
+      - NODE_RPC_URL=http://arda:26657
+      - FAUCET_URL=http://arda:4500
+      - ARDA_HOME=/data/.arda-poc               # <-- tell sidecar where to find the keyring
+    depends_on:
+      - arda
+
+volumes:
+  arda_state:
+  sidecar_data: