Merge pull request #3 from kjannette/format-majorly

Format majorly

.dockerignore

@@ -0,0 +1,3 @@
+.git
+node_modules
+.DS_Store

.editorconfig

@@ -0,0 +1,15 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[Makefile]
+indent_style = tab
+
+[*.go]
+indent_style = tab

.gitea/workflows/check.yml

@@ -0,0 +1,9 @@
+name: check
+on: [push]
+jobs:
+    check:
+        runs-on: ubuntu-latest
+        steps:
+            # actions/checkout v4.2.2, 2026-02-22
+            - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+            - run: docker build .

.gitignore

@@ -0,0 +1,44 @@
+# OS
+.DS_Store
+Thumbs.db
+
+# Editors
+*.swp
+*.swo
+*~
+*.bak
+.idea/
+.vscode/
+*.sublime-*
+
+# Node
+node_modules/
+
+# Environment / secrets
+.env
+.env.*
+*.pem
+*.key
+
+# Go build artifacts
+backend-go/bin/
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+*.test
+*.out
+vendor/
+tmp/
+
+# Frontend build output
+frontend/dist/
+frontend/build/
+frontend/.vite/
+
+# Prompts directory (local tooling, not part of the project)
+Prompts/
+
+# Logs
+*.log

.prettierignore

@@ -0,0 +1,7 @@
+node_modules/
+frontend/dist/
+frontend/build/
+backend-go/bin/
+*.lock
+Prompts/
+.claude/

.prettierrc

@@ -0,0 +1,4 @@
+{
+    "tabWidth": 4,
+    "proseWrap": "always"
+}

Dockerfile

@@ -0,0 +1,22 @@
+# syntax=docker/dockerfile:1
+
+# golang:1.24-alpine, 2025-02-28
+FROM golang:1.24-alpine@sha256:8bee1901f1e530bfb4a7850aa7a479d17ae3a18beb6e09064ed54cfd245b7191
+
+# Install system dependencies: Node.js, npm, make, git
+RUN apk add --no-cache nodejs npm make git
+
+# Install golangci-lint at a pinned commit hash
+# golangci-lint v2.10.1 (2025-02-17), commit 5d1e709b7be35cb2025444e19de266b056b7b7ee
+RUN GOBIN=/usr/local/bin go install \
+    github.com/golangci/golangci-lint/cmd/golangci-lint@5d1e709b7be35cb2025444e19de266b056b7b7ee
+
+WORKDIR /app
+
+COPY . .
+
+# Install frontend dependencies
+RUN cd frontend && npm ci
+
+# Run all checks — build fails if the branch is not green
+RUN make check

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Steven Jannette
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -0,0 +1,90 @@
+.PHONY: test lint fmt fmt-check check docker hooks build run dev clean \
+        test-go test-js lint-go lint-js fmt-go fmt-js fmt-check-go fmt-check-js \
+        build-go build-js
+
+GODIR    := backend-go
+JSDIR    := frontend
+PRETTIER := $(JSDIR)/node_modules/.bin/prettier
+
+# ── required targets ────────────────────────────────────────────
+
+all: check
+
+check: test lint fmt-check
+
+test: test-go test-js
+
+lint: lint-go lint-js
+
+fmt: fmt-go fmt-js
+
+fmt-check: fmt-check-go fmt-check-js
+
+# ── go ──────────────────────────────────────────────────────────
+
+test-go:
+	cd $(GODIR) && go test -timeout 30s ./...
+
+lint-go:
+	cd $(GODIR) && golangci-lint run ./...
+
+fmt-go:
+	cd $(GODIR) && gofmt -w .
+
+fmt-check-go:
+	@diff=$$(cd $(GODIR) && gofmt -l .); \
+	if [ -n "$$diff" ]; then \
+		echo "Go files need formatting:"; \
+		echo "$$diff"; \
+		exit 1; \
+	fi
+
+# ── js / frontend ───────────────────────────────────────────────
+
+test-js:
+	cd $(JSDIR) && npm test
+
+lint-js:
+	$(PRETTIER) --check '**/*.{js,jsx,ts,tsx,css,md,json}'
+
+fmt-js:
+	$(PRETTIER) --write '**/*.{js,jsx,ts,tsx,css,md,json}'
+
+fmt-check-js:
+	$(PRETTIER) --check '**/*.{js,jsx,ts,tsx,css,md,json}'
+
+# ── build ───────────────────────────────────────────────────────
+
+build: build-go build-js
+
+build-go:
+	cd $(GODIR) && go build -o bin/api ./cmd/api
+	cd $(GODIR) && go build -o bin/poller ./cmd/poller
+
+build-js:
+	cd $(JSDIR) && npm run build
+
+# ── dev / run ───────────────────────────────────────────────────
+
+run:
+	cd $(GODIR) && go run ./cmd/api
+
+dev:
+	cd $(GODIR) && go run ./cmd/api
+
+# ── docker ──────────────────────────────────────────────────────
+
+docker:
+	docker build -t koin-ping .
+
+# ── hooks ───────────────────────────────────────────────────────
+
+hooks:
+	printf '#!/bin/sh\nmake check\n' > .git/hooks/pre-commit
+	chmod +x .git/hooks/pre-commit
+
+# ── clean ───────────────────────────────────────────────────────
+
+clean:
+	rm -rf $(GODIR)/bin/
+	rm -rf $(JSDIR)/dist/

README.md

@@ -1,95 +1,122 @@
 # Koin Ping
 
-A lightweight on-chain monitoring and alerting system designed to give users situational awareness over blockchain addresses they care about.
+Koin Ping is an MIT-licensed blockchain monitoring system by Steven Jannette
-
+that polls Ethereum addresses for on-chain activity and delivers real-time
-## Overview
+alerts to users via a Go REST API backend and a React single-page application
-
+frontend.
-Koin Ping is designed to reliably observe on-chain activity and notify users when predefined conditions are met. It does not execute transactions, manage wallets, or speculate on prices.
-
-## Project Structure
-
-```
-koin_ping/
-├── backend/                  # Node.js + Express + PostgreSQL backend
-│   ├── api/                 # API endpoints and server configuration
-│   ├── poller/              # Blockchain polling logic
-│   ├── alerts/              # Alert evaluation and management
-│   ├── notifications/       # Notification delivery system
-│   ├── domain/              # Domain models and business logic
-│   ├── infra/               # Infrastructure (database, external services)
-│   └── shared/              # Shared utilities and helpers
-│
-└── frontend/                 # React + Vite frontend
-    ├── public/              # Static assets
-    └── src/
-        ├── api/             # Frontend API calls to backend
-        ├── components/      # Reusable UI components
-        ├── pages/           # Top-level pages (views)
-        └── utils/           # Utility functions
-
-```
-
-## Tech Stack
-
-### Backend
-- **Runtime:** Node.js
-- **Framework:** Express
-- **Database:** PostgreSQL
-- **Key Dependencies:** 
-  - `pg` - PostgreSQL client
-  - `dotenv` - Environment variable management
-  - `cors` - CORS middleware
-  - `nodemon` - Development auto-reload
-
-### Frontend
-- **Framework:** React 19
-- **Build Tool:** Vite
-- **Language:** JavaScript/TypeScript (mixed)
-- **Type Checking:** TypeScript
 
 ## Getting Started
 
 ### Prerequisites
-- Node.js (v18 or higher recommended)
-- PostgreSQL database
-- npm or yarn
 
-### Backend Setup
+- Go 1.24+
+- Node.js 18+ and npm (or yarn — preferred per repo policy)
+- PostgreSQL 15+
+- `golangci-lint` v2 (for `make lint`)
 
-1. Navigate to the backend directory:
+### Setup
-   ```bash
-   cd backend
-   ```
 
-2. Install dependencies (already done):
+```bash
-   ```bash
+# Clone and enter the repo
-   npm install
+git clone <repo-url>
-   ```
+cd koin_ping_0.2.0
 
-3. Create a `.env` file (see backend/README.md for required variables)
+# Install pre-commit hook
+make hooks
 
-4. Start the development server:
+# Install frontend dependencies
-   ```bash
+cd frontend && npm install && cd ..
-   npm run dev
-   ```
 
-The backend will run on `http://localhost:3001`
+# Copy and fill in environment variables
+cp backend-go/.env.example backend-go/.env
+# edit backend-go/.env with your DATABASE_URL, FIREBASE_PROJECT_ID, ETH_RPC_URL
 
-### Frontend Setup
+# Run checks (requires golangci-lint)
+make check
 
-1. Navigate to the frontend directory:
+# Start the API server
-   ```bash
+make run
-   cd frontend
-   ```
 
-2. Install dependencies (already done):
+# Start the poller (separate terminal)
-   ```bash
+cd backend-go && go run ./cmd/poller
-   npm install
-   ```
 
-3. Start the development server:
+# Start the frontend dev server (separate terminal)
-   ```bash
+cd frontend && npm run dev
-   npm run dev
+```
-   ```
 
-The frontend will run on `http://localhost:3000`
+The API listens on `http://localhost:3001` and the frontend on
+`http://localhost:3000` by default.
+
+## Rationale
+
+Crypto users who hold or actively monitor addresses need a lightweight, reliable
+way to know when on-chain activity occurs without polling block explorers
+manually. Koin Ping fills that gap: it watches a set of Ethereum addresses,
+evaluates configurable alert rules (incoming transactions, outgoing
+transactions, large transfers, balance thresholds), and notifies the user
+through Discord webhooks.
+
+## Design
+
+The system is split into two independently deployable processes and one
+frontend:
+
+```
+koin_ping_0.2.0/
+├── backend-go/                # Go monorepo root
+│   ├── cmd/api/               # HTTP REST API server
+│   ├── cmd/poller/            # Blockchain polling daemon
+│   └── internal/
+│       ├── config/            # Environment-based config loading
+│       ├── database/          # pgx connection pool
+│       ├── domain/            # Shared domain types
+│       ├── firebase/          # Firebase auth client
+│       ├── handlers/          # HTTP handler wiring
+│       ├── middleware/         # Auth middleware
+│       ├── models/            # SQL persistence layer
+│       ├── notifications/     # Discord webhook delivery
+│       ├── protocols/ethereum/ # Ethereum JSON-RPC client
+│       ├── services/          # Observer and evaluator business logic
+│       └── wei/               # ETH/Wei conversion utilities
+└── frontend/                  # React + Vite SPA
+    └── src/
+        ├── api/               # Fetch wrappers for the REST API
+        ├── components/        # Reusable UI components
+        ├── contexts/          # React contexts (auth, etc.)
+        ├── firebase/          # Firebase SDK initialization
+        └── pages/             # Top-level route pages
+```
+
+**API server** (`cmd/api`): standard-library `net/http` with Firebase JWT
+authentication middleware. Exposes CRUD endpoints for addresses, alert rules,
+alert events, and notification configuration.
+
+**Poller** (`cmd/poller`): long-running daemon that polls Ethereum via JSON-RPC,
+compares observed transactions against persisted alert rules, fires alert events
+to the database, and dispatches Discord notifications.
+
+**Frontend** (`frontend/`): React 19 SPA built with Vite. Authenticates with
+Firebase, communicates with the API via fetch, and renders the address/alert
+management UI.
+
+## TODO
+
+- [ ] Switch frontend package manager from npm to yarn (per repo policy)
+- [ ] Rename `go.mod` module path from `github.com/kjannette/koin-ping` to
+      `sneak.berlin/go/koin-ping` (per repo policy)
+- [ ] Move database migrations to `internal/db/migrations/` and embed them in
+      the binary
+- [ ] Pin all Docker base images by `@sha256` in Dockerfile
+- [ ] Install `golangci-lint` locally and pass `make lint`
+- [ ] Add vitest unit tests for the React frontend
+- [ ] Add a `make db-reset` / `make migrate` target for schema management
+- [ ] Set HTTP server read/write timeouts (currently unbounded)
+- [ ] Replace `log.Printf` calls with structured `log/slog`
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Author
+
+Steven Jannette

REPO_POLICIES.md

@@ -0,0 +1,188 @@
+---
+title: Repository Policies
+last_modified: 2026-02-22
+---
+
+This document covers repository structure, tooling, and workflow standards. Code
+style conventions are in separate documents:
+
+- [Code Styleguide](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/CODE_STYLEGUIDE.md)
+  (general, bash, Docker)
+- [Go](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/CODE_STYLEGUIDE_GO.md)
+- [JavaScript](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/CODE_STYLEGUIDE_JS.md)
+- [Python](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/CODE_STYLEGUIDE_PYTHON.md)
+- [Go HTTP Server Conventions](https://git.eeqj.de/sneak/prompts/raw/branch/main/prompts/GO_HTTP_SERVER_CONVENTIONS.md)
+
+---
+
+- Cross-project documentation (such as this file) must include
+  `last_modified: YYYY-MM-DD` in the YAML front matter so it can be kept in sync
+  with the authoritative source as policies evolve.
+
+- **ALL external references must be pinned by cryptographic hash.** This
+  includes Docker base images, Go modules, npm packages, GitHub Actions, and
+  anything else fetched from a remote source. Version tags (`@v4`, `@latest`,
+  `:3.21`, etc.) are server-mutable and therefore remote code execution
+  vulnerabilities. The ONLY acceptable way to reference an external dependency
+  is by its content hash (Docker `@sha256:...`, Go module hash in `go.sum`, npm
+  integrity hash in lockfile, GitHub Actions `@<commit-sha>`). No exceptions.
+  This also means never `curl | bash` to install tools like pyenv, nvm, rustup,
+  etc. Instead, download a specific release archive from GitHub, verify its hash
+  (hardcoded in the Dockerfile or script), and only then install. Unverified
+  install scripts are arbitrary remote code execution. This is the single most
+  important rule in this document. Double-check every external reference in
+  every file before committing. There are zero exceptions to this rule.
+
+- Every repo with software must have a root `Makefile` with these targets:
+  `make test`, `make lint`, `make fmt` (writes), `make fmt-check` (read-only),
+  `make check` (prereqs: `test`, `lint`, `fmt-check`), `make docker`, and
+  `make hooks` (installs pre-commit hook). A model Makefile is at
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/Makefile`.
+
+- Always use Makefile targets (`make fmt`, `make test`, `make lint`, etc.)
+  instead of invoking the underlying tools directly. The Makefile is the single
+  source of truth for how these operations are run.
+
+- The Makefile is authoritative documentation for how the repo is used. Beyond
+  the required targets above, it should have targets for every common operation:
+  running a local development server (`make run`, `make dev`), re-initializing
+  or migrating the database (`make db-reset`, `make migrate`), building
+  artifacts (`make build`), generating code, seeding data, or anything else a
+  developer would do regularly. If someone checks out the repo and types
+  `make<tab>`, they should see every meaningful operation available. A new
+  contributor should be able to understand the entire development workflow by
+  reading the Makefile.
+
+- Every repo should have a `Dockerfile`. All Dockerfiles must run `make check`
+  as a build step so the build fails if the branch is not green. For non-server
+  repos, the Dockerfile should bring up a development environment and run
+  `make check`. For server repos, `make check` should run as an early build
+  stage before the final image is assembled.
+
+- Every repo should have a Gitea Actions workflow (`.gitea/workflows/`) that
+  runs `docker build .` on push. Since the Dockerfile already runs `make check`,
+  a successful build implies all checks pass.
+
+- Use platform-standard formatters: `black` for Python, `prettier` for
+  JS/CSS/Markdown/HTML, `go fmt` for Go. Always use default configuration with
+  two exceptions: four-space indents (except Go), and `proseWrap: always` for
+  Markdown (hard-wrap at 80 columns). Documentation and writing repos (Markdown,
+  HTML, CSS) should also have `.prettierrc` and `.prettierignore`.
+
+- Pre-commit hook: `make check` if local testing is possible, otherwise
+  `make lint && make fmt-check`. The Makefile should provide a `make hooks`
+  target to install the pre-commit hook.
+
+- All repos with software must have tests that run via the platform-standard
+  test framework (`go test`, `pytest`, `jest`/`vitest`, etc.). If no meaningful
+  tests exist yet, add the most minimal test possible — e.g. importing the
+  module under test to verify it compiles/parses. There is no excuse for
+  `make test` to be a no-op.
+
+- `make test` must complete in under 20 seconds. Add a 30-second timeout in the
+  Makefile.
+
+- Docker builds must complete in under 5 minutes.
+
+- `make check` must not modify any files in the repo. Tests may use temporary
+  directories.
+
+- `main` must always pass `make check`, no exceptions.
+
+- Never commit secrets. `.env` files, credentials, API keys, and private keys
+  must be in `.gitignore`. No exceptions.
+
+- `.gitignore` should be comprehensive from the start: OS files (`.DS_Store`),
+  editor files (`.swp`, `*~`), language build artifacts, and `node_modules/`.
+  Fetch the standard `.gitignore` from
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.gitignore` when setting up
+  a new repo.
+
+- Never use `git add -A` or `git add .`. Always stage files explicitly by name.
+
+- Never force-push to `main`.
+
+- Make all changes on a feature branch. You can do whatever you want on a
+  feature branch.
+
+- `.golangci.yml` is standardized and must _NEVER_ be modified by an agent, only
+  manually by the user. Fetch from
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/.golangci.yml`.
+
+- When pinning images or packages by hash, add a comment above the reference
+  with the version and date (YYYY-MM-DD).
+
+- Use `yarn`, not `npm`.
+
+- Write all dates as YYYY-MM-DD (ISO 8601).
+
+- Simple projects should be configured with environment variables.
+
+- Dockerized web services listen on port 8080 by default, overridable with
+  `PORT`.
+
+- `README.md` is the primary documentation. Required sections:
+    - **Description**: First line must include the project name, purpose,
+      category (web server, SPA, CLI tool, etc.), license, and author. Example:
+      "µPaaS is an MIT-licensed Go web application by @sneak that receives
+      git-frontend webhooks and deploys applications via Docker in realtime."
+    - **Getting Started**: Copy-pasteable install/usage code block.
+    - **Rationale**: Why does this exist?
+    - **Design**: How is the program structured?
+    - **TODO**: Update meticulously, even between commits. When planning, put
+      the todo list in the README so a new agent can pick up where the last one
+      left off.
+    - **License**: MIT, GPL, or WTFPL. Ask the user for new projects. Include a
+      `LICENSE` file in the repo root and a License section in the README.
+    - **Author**: [@sneak](https://sneak.berlin).
+
+- First commit of a new repo should contain only `README.md`.
+
+- Go module root: `sneak.berlin/go/<name>`. Always run `go mod tidy` before
+  committing.
+
+- Use SemVer.
+
+- Database migrations live in `internal/db/migrations/` and must be embedded in
+  the binary.
+    - `000_migration.sql` — contains ONLY the creation of the migrations
+      tracking table itself. Nothing else.
+    - `001_schema.sql` — the full application schema.
+    - **Pre-1.0.0:** never add additional migration files (002, 003, etc.).
+      There is no installed base to migrate. Edit `001_schema.sql` directly.
+    - **Post-1.0.0:** add new numbered migration files for each schema change.
+      Never edit existing migrations after release.
+
+- All repos should have an `.editorconfig` enforcing the project's indentation
+  settings.
+
+- Avoid putting files in the repo root unless necessary. Root should contain
+  only project-level config files (`README.md`, `Makefile`, `Dockerfile`,
+  `LICENSE`, `.gitignore`, `.editorconfig`, `REPO_POLICIES.md`, and
+  language-specific config). Everything else goes in a subdirectory. Canonical
+  subdirectory names:
+    - `bin/` — executable scripts and tools
+    - `cmd/` — Go command entrypoints
+    - `configs/` — configuration templates and examples
+    - `deploy/` — deployment manifests (k8s, compose, terraform)
+    - `docs/` — documentation and markdown (README.md stays in root)
+    - `internal/` — Go internal packages
+    - `internal/db/migrations/` — database migrations
+    - `pkg/` — Go library packages
+    - `share/` — systemd units, data files
+    - `static/` — static assets (images, fonts, etc.)
+    - `web/` — web frontend source
+
+- When setting up a new repo, files from the `prompts` repo may be used as
+  templates. Fetch them from
+  `https://git.eeqj.de/sneak/prompts/raw/branch/main/<path>`.
+
+- New repos must contain at minimum:
+    - `README.md`, `.git`, `.gitignore`, `.editorconfig`
+    - `LICENSE`, `REPO_POLICIES.md` (copy from the `prompts` repo)
+    - `Makefile`
+    - `Dockerfile`, `.dockerignore`
+    - `.gitea/workflows/check.yml`
+    - Go: `go.mod`, `go.sum`, `.golangci.yml`
+    - JS: `package.json`, `yarn.lock`, `.prettierrc`, `.prettierignore`
+    - Python: `pyproject.toml`

backend-go/.golangci.yml

@@ -0,0 +1,32 @@
+version: "2"
+
+run:
+  timeout: 5m
+  modules-download-mode: readonly
+
+linters:
+  default: all
+  disable:
+    # Genuinely incompatible with project patterns
+    - exhaustruct      # Requires all struct fields
+    - depguard         # Dependency allow/block lists
+    - godot            # Requires comments to end with periods
+    - wsl              # Deprecated, replaced by wsl_v5
+    - wrapcheck        # Too verbose for internal packages
+    - varnamelen       # Short names like db, id are idiomatic Go
+
+linters-settings:
+  lll:
+    line-length: 88
+  funlen:
+    lines: 80
+    statements: 50
+  cyclop:
+    max-complexity: 15
+  dupl:
+    threshold: 100
+
+issues:
+  exclude-use-default: false
+  max-issues-per-linter: 0
+  max-same-issues: 0

backend-go/ENV_TEMPLATE.md

@@ -37,16 +37,20 @@ cp ENV_TEMPLATE.md .env
 
 ## Firebase Setup
 
-For Firebase Admin SDK to work, you need to set up Application Default Credentials:
+For Firebase Admin SDK to work, you need to set up Application Default
+Credentials:
 
 **Option 1: Use Firebase Project ID (easiest for development)**
+
 - Just set `FIREBASE_PROJECT_ID` in .env
 - Firebase Admin will use Application Default Credentials
 
 **Option 2: Use Service Account Key (production)**
+
 1. Go to Firebase Console > Project Settings > Service Accounts
 2. Click "Generate new private key"
 3. Download the JSON file
 4. Either:
-   - Set `GOOGLE_APPLICATION_CREDENTIALS=/path/to/serviceAccountKey.json` in .env
+    - Set `GOOGLE_APPLICATION_CREDENTIALS=/path/to/serviceAccountKey.json` in
-   - Or keep it in backend/ and add to .gitignore
+      .env
+    - Or keep it in backend/ and add to .gitignore

backend-go/README.md

@@ -1,4 +1,7 @@
+Start DB:
+
+brew services start postgresql@15
+
 Run Backend:
 
-cd /Users/kjannette/workspace/koin_ping/backend-go
+cd /Users/kjannette/workspace/koin_ping/backend-go go run ./cmd/api
-go run ./cmd/api

backend-go/cmd/api/main.go

@@ -1,10 +1,11 @@
+// Package main is the entry point for the API server.
 package main
 
 import (
 	"fmt"
 	"log"
 	"net/http"
-	"os"
+	"time"
 
 	"github.com/joho/godotenv"
 	"github.com/kjannette/koin-ping/backend-go/internal/config"
@@ -15,6 +16,14 @@ import (
 	"github.com/kjannette/koin-ping/backend-go/internal/models"
 )
 
+const (
+	// serverReadTimeoutSeconds is the maximum duration to read a request.
+	serverReadTimeoutSeconds = 5
+	// serverWriteTimeoutSeconds is the maximum duration to write a response.
+	serverWriteTimeoutSeconds = 10
+)
+
+//nolint:funlen
 func main() {
 	_ = godotenv.Load() // .env is optional; env vars can also be set externally
 
@@ -27,12 +36,13 @@ func main() {
 	if err != nil {
 		log.Fatalf("Failed to connect to database: %v", err)
 	}
-	defer database.Close()
 
 	if err := firebase.Init(cfg.FirebaseProjectID); err != nil {
 		log.Fatalf("Failed to initialize Firebase: %v", err)
 	}
 
+	defer database.Close()
+
 	addressModel := models.NewAddressModel(pool)
 	alertRuleModel := models.NewAlertRuleModel(pool)
 	alertEventModel := models.NewAlertEventModel(pool)
@@ -51,23 +61,34 @@ func main() {
 	mux.HandleFunc("GET "+b+"/status", handlers.SystemStatus)
 
 	// Authenticated routes — addresses
-	mux.Handle("POST "+b+"/addresses", middleware.Authenticate(http.HandlerFunc(addressHandler.Create)))
+	mux.Handle("POST "+b+"/addresses",
-	mux.Handle("GET "+b+"/addresses", middleware.Authenticate(http.HandlerFunc(addressHandler.List)))
+		middleware.Authenticate(http.HandlerFunc(addressHandler.Create)))
-	mux.Handle("DELETE "+b+"/addresses/{addressId}", middleware.Authenticate(http.HandlerFunc(addressHandler.Remove)))
+	mux.Handle("GET "+b+"/addresses",
+		middleware.Authenticate(http.HandlerFunc(addressHandler.List)))
+	mux.Handle("DELETE "+b+"/addresses/{addressId}",
+		middleware.Authenticate(http.HandlerFunc(addressHandler.Remove)))
 
 	// Authenticated routes — alert rules
-	mux.Handle("POST "+b+"/addresses/{addressId}/alerts", middleware.Authenticate(http.HandlerFunc(alertRuleHandler.Create)))
+	mux.Handle("POST "+b+"/addresses/{addressId}/alerts",
-	mux.Handle("GET "+b+"/addresses/{addressId}/alerts", middleware.Authenticate(http.HandlerFunc(alertRuleHandler.ListByAddress)))
+		middleware.Authenticate(http.HandlerFunc(alertRuleHandler.Create)))
-	mux.Handle("PATCH "+b+"/alerts/{alertId}", middleware.Authenticate(http.HandlerFunc(alertRuleHandler.UpdateStatus)))
+	mux.Handle("GET "+b+"/addresses/{addressId}/alerts",
-	mux.Handle("DELETE "+b+"/alerts/{alertId}", middleware.Authenticate(http.HandlerFunc(alertRuleHandler.Remove)))
+		middleware.Authenticate(http.HandlerFunc(alertRuleHandler.ListByAddress)))
+	mux.Handle("PATCH "+b+"/alerts/{alertId}",
+		middleware.Authenticate(http.HandlerFunc(alertRuleHandler.UpdateStatus)))
+	mux.Handle("DELETE "+b+"/alerts/{alertId}",
+		middleware.Authenticate(http.HandlerFunc(alertRuleHandler.Remove)))
 
 	// Authenticated routes — alert events
-	mux.Handle("GET "+b+"/alert-events", middleware.Authenticate(http.HandlerFunc(alertEventHandler.List)))
+	mux.Handle("GET "+b+"/alert-events",
+		middleware.Authenticate(http.HandlerFunc(alertEventHandler.List)))
 
 	// Authenticated routes — notification config
-	mux.Handle("GET "+b+"/notification-config", middleware.Authenticate(http.HandlerFunc(notifConfigHandler.GetConfig)))
+	mux.Handle("GET "+b+"/notification-config",
-	mux.Handle("PUT "+b+"/notification-config", middleware.Authenticate(http.HandlerFunc(notifConfigHandler.UpdateConfig)))
+		middleware.Authenticate(http.HandlerFunc(notifConfigHandler.GetConfig)))
-	mux.Handle("DELETE "+b+"/notification-config", middleware.Authenticate(http.HandlerFunc(notifConfigHandler.DeleteConfig)))
+	mux.Handle("PUT "+b+"/notification-config",
+		middleware.Authenticate(http.HandlerFunc(notifConfigHandler.UpdateConfig)))
+	mux.Handle("DELETE "+b+"/notification-config",
+		middleware.Authenticate(http.HandlerFunc(notifConfigHandler.DeleteConfig)))
 
 	handler := corsMiddleware(mux)
 
@@ -76,9 +97,14 @@ func main() {
 	log.Printf("API base path: %s", cfg.APIBasePath)
 	log.Printf("Environment: %s", cfg.NodeEnv)
 
-	if err := http.ListenAndServe(addr, handler); err != nil {
+	server := &http.Server{
+		Addr:         addr,
+		Handler:      handler,
+		ReadTimeout:  serverReadTimeoutSeconds * time.Second,
+		WriteTimeout: serverWriteTimeoutSeconds * time.Second,
+	}
+	if err := server.ListenAndServe(); err != nil {
 		log.Fatalf("Server failed: %v", err)
-		os.Exit(1)
 	}
 }
 
@@ -90,6 +116,7 @@ func corsMiddleware(next http.Handler) http.Handler {
 
 		if r.Method == http.MethodOptions {
 			w.WriteHeader(http.StatusNoContent)
+
 			return
 		}
 

backend-go/cmd/poller/main.go

@@ -1,3 +1,4 @@
+// Package main is the entry point for the blockchain observer poller.
 package main
 
 import (
@@ -18,6 +19,14 @@ import (
 	"github.com/kjannette/koin-ping/backend-go/internal/services"
 )
 
+const (
+	// separatorWidth is the number of characters in log separator lines.
+	separatorWidth = 60
+	// msPerSecond converts milliseconds to seconds.
+	msPerSecond = 1000
+)
+
+//nolint:funlen
 func main() {
 	_ = godotenv.Load()
 
@@ -34,13 +43,14 @@ func main() {
 	if err != nil {
 		log.Fatalf("Failed to connect to database: %v", err)
 	}
-	defer database.Close()
 
 	eth, err := ethereum.NewJsonRpcEthereum(cfg.EthRPCURL)
 	if err != nil {
 		log.Fatalf("Failed to create Ethereum observer: %v", err)
 	}
 
+	defer database.Close()
+
 	addressModel := models.NewAddressModel(pool)
 	alertRuleModel := models.NewAlertRuleModel(pool)
 	alertEventModel := models.NewAlertEventModel(pool)
@@ -58,20 +68,20 @@ func main() {
 	go func() {
 		<-sigCh
 		log.Println()
-		log.Println(strings.Repeat("=", 60))
+		log.Println(strings.Repeat("=", separatorWidth))
 		log.Println("Shutting down poller gracefully...")
-		log.Println(strings.Repeat("=", 60))
+		log.Println(strings.Repeat("=", separatorWidth))
 		cancel()
 	}()
 
 	interval := time.Duration(cfg.PollIntervalMS) * time.Millisecond
 
-	log.Println(strings.Repeat("=", 60))
+	log.Println(strings.Repeat("=", separatorWidth))
 	log.Println("Koin Ping Observer Poller Starting")
-	log.Println(strings.Repeat("=", 60))
+	log.Println(strings.Repeat("=", separatorWidth))
 	log.Printf("RPC URL: %s", cfg.EthRPCURL)
-	log.Printf("Poll Interval: %dms (%ds)", cfg.PollIntervalMS, cfg.PollIntervalMS/1000)
+	log.Printf("Poll Interval: %dms (%ds)", cfg.PollIntervalMS, cfg.PollIntervalMS/msPerSecond)
-	log.Println(strings.Repeat("=", 60))
+	log.Println(strings.Repeat("=", separatorWidth))
 
 	runCycle(ctx, observer, evaluator)
 
@@ -82,6 +92,7 @@ func main() {
 		select {
 		case <-ctx.Done():
 			log.Println("Poller stopped")
+
 			return
 		case <-ticker.C:
 			runCycle(ctx, observer, evaluator)
@@ -89,19 +100,25 @@ func main() {
 	}
 }
 
-func runCycle(ctx context.Context, observer *services.ObserverService, evaluator *services.EvaluatorService) {
+func runCycle(
+	ctx context.Context,
+	observer *services.ObserverService,
+	evaluator *services.EvaluatorService,
+) {
 	startTime := time.Now()
 	log.Printf("[%s] Starting observation cycle...", time.Now().UTC().Format(time.RFC3339))
 
 	observations, err := observer.RunOnce(ctx)
 	if err != nil {
 		log.Printf("[%s] Observation cycle failed: %v", time.Now().UTC().Format(time.RFC3339), err)
+
 		return
 	}
 
 	alertsFired, err := evaluator.Evaluate(ctx, observations)
 	if err != nil {
 		log.Printf("[%s] Evaluation failed: %v", time.Now().UTC().Format(time.RFC3339), err)
+
 		return
 	}
 

backend-go/internal/config/config.go

@@ -1,3 +1,4 @@
+//loads environment-based configuration.
 package config
 
 import (
@@ -7,6 +8,13 @@ import (
 	"strings"
 )
 
+const (
+	defaultPort = 3001
+	defaultDBPort = 5432
+	defaultPollIntervalMS = 60000
+	minPollIntervalMS = 1000
+)
+
 type Config struct {
 	Port              int
 	APIBasePath       string
@@ -22,24 +30,25 @@ type Config struct {
 	NodeEnv           string
 }
 
+// Load reads configuration from environment variables and returns a Config.
 func Load() (*Config, error) {
 	cfg := &Config{
-		Port:           getEnvInt("PORT", 3001),
+		Port:              getEnvInt("PORT", defaultPort),
-		APIBasePath:    getEnv("API_BASE_PATH", "/v1"),
+		APIBasePath:       getEnv("API_BASE_PATH", "/v1"),
-		DatabaseURL:    os.Getenv("DATABASE_URL"),
+		DatabaseURL:       os.Getenv("DATABASE_URL"),
-		DBHost:         getEnv("DB_HOST", "localhost"),
+		DBHost:            getEnv("DB_HOST", "localhost"),
-		DBPort:         getEnvInt("DB_PORT", 5432),
+		DBPort:            getEnvInt("DB_PORT", defaultDBPort),
-		DBUser:         os.Getenv("DB_USER"),
+		DBUser:            os.Getenv("DB_USER"),
-		DBPassword:     os.Getenv("DB_PASSWORD"),
+		DBPassword:        os.Getenv("DB_PASSWORD"),
-		DBName:         os.Getenv("DB_NAME"),
+		DBName:            os.Getenv("DB_NAME"),
 		FirebaseProjectID: os.Getenv("FIREBASE_PROJECT_ID"),
-		EthRPCURL:      os.Getenv("ETH_RPC_URL"),
+		EthRPCURL:         os.Getenv("ETH_RPC_URL"),
-		PollIntervalMS: getEnvInt("POLL_INTERVAL_MS", 60000),
+		PollIntervalMS:    getEnvInt("POLL_INTERVAL_MS", defaultPollIntervalMS),
-		NodeEnv:        getEnv("NODE_ENV", "development"),
+		NodeEnv:           getEnv("NODE_ENV", "development"),
 	}
 
-	if cfg.PollIntervalMS < 1000 {
+	if cfg.PollIntervalMS < minPollIntervalMS {
-		return nil, fmt.Errorf("POLL_INTERVAL_MS must be >= 1000, got %d", cfg.PollIntervalMS)
+		return nil, fmt.Errorf("POLL_INTERVAL_MS must be >= 1000, got %d", cfg.PollIntervalMS) //nolint:err113
 	}
 
 	return cfg, nil
@@ -47,17 +56,19 @@ func Load() (*Config, error) {
 
 func (c *Config) DSN() string {
 	if c.DatabaseURL != "" {
-		// pgx defaults to sslmode=prefer, which fails against local Postgres.
 		// Append sslmode=disable if not already specified.
 		if !strings.Contains(c.DatabaseURL, "sslmode=") {
 			sep := "?"
 			if strings.Contains(c.DatabaseURL, "?") {
 				sep = "&"
 			}
+
 			return c.DatabaseURL + sep + "sslmode=disable"
 		}
+
 		return c.DatabaseURL
 	}
+
 	return fmt.Sprintf(
 		"host=%s port=%d user=%s password=%s dbname=%s sslmode=disable",
 		c.DBHost, c.DBPort, c.DBUser, c.DBPassword, c.DBName,
@@ -68,6 +79,7 @@ func getEnv(key, fallback string) string {
 	if v := os.Getenv(key); v != "" {
 		return v
 	}
+
 	return fallback
 }
 
@@ -77,5 +89,6 @@ func getEnvInt(key string, fallback int) int {
 			return n
 		}
 	}
+
 	return fallback
 }

backend-go/internal/database/postgres.go

@@ -1,3 +1,4 @@
+// Package database manages PostgreSQL connection pools.
 package database
 
 import (
@@ -9,20 +10,34 @@ import (
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 
-var pool *pgxpool.Pool
+const (
+	// maxConnIdleSeconds is the maximum idle time for a connection.
+	maxConnIdleSeconds = 30
+	// maxConnLifetimeMinutes is the maximum lifetime for a connection.
+	maxConnLifetimeMinutes = 5
+	// connectTimeoutSeconds is the timeout for initial connection.
+	connectTimeoutSeconds = 10
+	// maxConns is the maximum number of connections in the pool.
+	maxConns = 20
+	// minConns is the minimum number of connections in the pool.
+	minConns = 2
+)
 
+var pool *pgxpool.Pool //nolint:gochecknoglobals
+
+// Connect establishes a PostgreSQL connection pool using the given DSN.
 func Connect(dsn string) (*pgxpool.Pool, error) {
 	cfg, err := pgxpool.ParseConfig(dsn)
 	if err != nil {
 		return nil, fmt.Errorf("parse database config: %w", err)
 	}
 
-	cfg.MaxConns = 20
+	cfg.MaxConns = maxConns
-	cfg.MinConns = 2
+	cfg.MinConns = minConns
-	cfg.MaxConnIdleTime = 30 * time.Second
+	cfg.MaxConnIdleTime = maxConnIdleSeconds * time.Second
-	cfg.MaxConnLifetime = 5 * time.Minute
+	cfg.MaxConnLifetime = maxConnLifetimeMinutes * time.Minute
 
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), connectTimeoutSeconds*time.Second)
 	defer cancel()
 
 	p, err := pgxpool.NewWithConfig(ctx, cfg)
@@ -32,18 +47,22 @@ func Connect(dsn string) (*pgxpool.Pool, error) {
 
 	if err := p.Ping(ctx); err != nil {
 		p.Close()
+
 		return nil, fmt.Errorf("ping database: %w", err)
 	}
 
 	log.Println("Connected to PostgreSQL database")
 	pool = p
+
 	return p, nil
 }
 
+// Pool returns the global connection pool.
 func Pool() *pgxpool.Pool {
 	return pool
 }
 
+// Close closes the global connection pool.
 func Close() {
 	if pool != nil {
 		pool.Close()

backend-go/internal/domain/types.go

@@ -1,17 +1,24 @@
+// Package domain defines core domain types shared across the application.
 package domain
 
 import "time"
 
+// Address represents a tracked Ethereum address.
 type Address struct {
 	ID        int       `json:"id"`
-	UserID    string    `json:"user_id"`
+	UserID    string    `json:"user_id"`    //nolint:tagliatelle
 	Address   string    `json:"address"`
 	Label     *string   `json:"label"`
-	CreatedAt time.Time `json:"created_at"`
+	CreatedAt time.Time `json:"created_at"` //nolint:tagliatelle
 }
 
+// AlertType identifies the kind of alert rule.
 type AlertType string
 
+// String implements fmt.Stringer.
+func (a AlertType) String() string { return string(a) }
+
+// Alert type constants define the supported alert triggers.
 const (
 	AlertIncomingTx    AlertType = "incoming_tx"
 	AlertOutgoingTx    AlertType = "outgoing_tx"
@@ -19,97 +26,115 @@ const (
 	AlertBalanceBelow  AlertType = "balance_below"
 )
 
-var ValidAlertTypes = []AlertType{
+// ValidAlertTypes lists all alert types accepted by the API.
+var ValidAlertTypes = []AlertType{ //nolint:gochecknoglobals
 	AlertIncomingTx,
 	AlertOutgoingTx,
 	AlertLargeTransfer,
 	AlertBalanceBelow,
 }
 
-var ThresholdRequiredTypes = []AlertType{
+// ThresholdRequiredTypes lists alert types that require a threshold value.
+var ThresholdRequiredTypes = []AlertType{ //nolint:gochecknoglobals
 	AlertLargeTransfer,
 	AlertBalanceBelow,
 }
 
+// IsValidAlertType returns true if the given string matches a known AlertType.
 func IsValidAlertType(t string) bool {
 	for _, v := range ValidAlertTypes {
 		if string(v) == t {
 			return true
 		}
 	}
+
 	return false
 }
 
+// IsThresholdRequired returns true if the given AlertType requires a threshold.
 func IsThresholdRequired(t AlertType) bool {
 	for _, v := range ThresholdRequiredTypes {
 		if v == t {
 			return true
 		}
 	}
+
 	return false
 }
 
+// AlertRule represents a user-defined alert rule for an address.
 type AlertRule struct {
 	ID        int       `json:"id"`
-	AddressID int       `json:"address_id"`
+	AddressID int       `json:"address_id"` //nolint:tagliatelle
 	Type      AlertType `json:"type"`
 	Threshold *float64  `json:"threshold"`
 	Enabled   bool      `json:"enabled"`
-	CreatedAt time.Time `json:"created_at"`
+	CreatedAt time.Time `json:"created_at"` //nolint:tagliatelle
 }
 
+// AlertEvent represents a fired alert event stored for history.
 type AlertEvent struct {
-	ID          int       `json:"id"`
+	ID           int       `json:"id"`
-	AlertRuleID int       `json:"alert_rule_id"`
+	AlertRuleID  int       `json:"alert_rule_id"`   //nolint:tagliatelle
-	Message     string    `json:"message"`
+	Message      string    `json:"message"`
-	AddressLabel *string  `json:"address_label"`
+	AddressLabel *string   `json:"address_label"`   //nolint:tagliatelle
-	TxHash      *string   `json:"tx_hash"`
+	TxHash       *string   `json:"tx_hash"`         //nolint:tagliatelle
-	Timestamp   time.Time `json:"timestamp"`
+	Timestamp    time.Time `json:"timestamp"`
 }
 
+// AddressCheckpoint tracks the last block checked for an address.
 type AddressCheckpoint struct {
-	AddressID        int       `json:"address_id"`
+	AddressID        int       `json:"address_id"`         //nolint:tagliatelle
-	LastCheckedBlock int       `json:"last_checked_block"`
+	LastCheckedBlock int       `json:"last_checked_block"` //nolint:tagliatelle
-	LastCheckedAt    time.Time `json:"last_checked_at"`
+	LastCheckedAt    time.Time `json:"last_checked_at"`    //nolint:tagliatelle
 }
 
+// CheckpointDetail combines checkpoint and address info for reporting.
 type CheckpointDetail struct {
-	AddressID        int       `json:"address_id"`
+	AddressID        int       `json:"address_id"`         //nolint:tagliatelle
 	Address          string    `json:"address"`
 	Label            *string   `json:"label"`
-	LastCheckedBlock int       `json:"last_checked_block"`
+	LastCheckedBlock int       `json:"last_checked_block"` //nolint:tagliatelle
-	LastCheckedAt    time.Time `json:"last_checked_at"`
+	LastCheckedAt    time.Time `json:"last_checked_at"`    //nolint:tagliatelle
 }
 
+// NotificationConfig holds a user's notification preferences.
 type NotificationConfig struct {
-	UserID              string  `json:"user_id"`
+	UserID              string     `json:"user_id"`              //nolint:tagliatelle
-	DiscordWebhookURL   *string `json:"discord_webhook_url"`
+	DiscordWebhookURL   *string    `json:"discord_webhook_url"`  //nolint:tagliatelle
-	TelegramChatID      *string `json:"telegram_chat_id"`
+	TelegramChatID      *string    `json:"telegram_chat_id"`     //nolint:tagliatelle
-	TelegramBotToken    *string `json:"telegram_bot_token,omitempty"`
+	TelegramBotToken    *string    `json:"telegram_bot_token,omitempty"` //nolint:tagliatelle
-	Email               *string `json:"email"`
+	Email               *string    `json:"email"`
-	NotificationEnabled bool    `json:"notification_enabled"`
+	NotificationEnabled bool       `json:"notification_enabled"` //nolint:tagliatelle
-	CreatedAt           *time.Time `json:"created_at,omitempty"`
+	CreatedAt           *time.Time `json:"created_at,omitempty"` //nolint:tagliatelle
-	UpdatedAt           *time.Time `json:"updated_at,omitempty"`
+	UpdatedAt           *time.Time `json:"updated_at,omitempty"` //nolint:tagliatelle
 }
 
+// NormalizedTx is a blockchain transaction normalized for internal use.
 type NormalizedTx struct {
-	Hash           string `json:"hash"`
+	Hash           string  `json:"hash"`
-	From           string `json:"from"`
+	From           string  `json:"from"`
 	To             *string `json:"to"`
-	Value          string `json:"value"` // Wei as string for precision
+	Value          string  `json:"value"` // Wei as string for precision
-	BlockNumber    int    `json:"block_number"`
+	BlockNumber    int     `json:"block_number"`    //nolint:tagliatelle
-	BlockTimestamp int64  `json:"block_timestamp"`
+	BlockTimestamp int64   `json:"block_timestamp"` //nolint:tagliatelle
 }
 
+// Direction indicates whether a transaction is incoming or outgoing.
 type Direction string
 
+// String implements fmt.Stringer.
+func (d Direction) String() string { return string(d) }
+
+// Direction constants indicate the flow of a transaction relative to a watched address.
 const (
 	DirectionIncoming Direction = "incoming"
 	DirectionOutgoing Direction = "outgoing"
 )
 
+// ObservedTx is a NormalizedTx enriched with address and direction context.
 type ObservedTx struct {
 	NormalizedTx
-	AddressID int       `json:"address_id"`
+	AddressID int       `json:"address_id"` //nolint:tagliatelle
 	Direction Direction `json:"direction"`
 }

backend-go/internal/firebase/admin.go

@@ -1,3 +1,4 @@
+// Package firebase provides Firebase authentication integration.
 package firebase
 
 import (
@@ -10,12 +11,13 @@ import (
 	"google.golang.org/api/option"
 )
 
-var (
+var ( //nolint:gochecknoglobals
-	authClient *auth.Client
+	authClient *auth.Client //nolint:gochecknoglobals
-	once       sync.Once
+	once       sync.Once    //nolint:gochecknoglobals
-	initErr    error
+	errInit    error        //nolint:gochecknoglobals
 )
 
+// Init initializes the Firebase app and auth client using the given project ID.
 func Init(projectID string) error {
 	once.Do(func() {
 		ctx := context.Background()
@@ -30,20 +32,23 @@ func Init(projectID string) error {
 			app, err = fb.NewApp(ctx, nil)
 		}
 		if err != nil {
-			initErr = fmt.Errorf("initialize firebase app: %w", err)
+			errInit = fmt.Errorf("initialize firebase app: %w", err)
+
 			return
 		}
 
 		authClient, err = app.Auth(ctx)
 		if err != nil {
-			initErr = fmt.Errorf("initialize firebase auth: %w", err)
+			errInit = fmt.Errorf("initialize firebase auth: %w", err)
+
 			return
 		}
 	})
 
-	return initErr
+	return errInit
 }
 
+// Auth returns the initialized Firebase auth client.
 func Auth() *auth.Client {
 	return authClient
 }

backend-go/internal/handlers/address.go

@@ -1,3 +1,4 @@
+// Package handlers implements HTTP request handlers for the API.
 package handlers
 
 import (
@@ -14,14 +15,17 @@ import (
 
 var ethAddressRe = regexp.MustCompile(`^0x[a-fA-F0-9]{40}$`)
 
+// AddressHandler handles HTTP requests for address management.
 type AddressHandler struct {
 	addresses *models.AddressModel
 }
 
+// NewAddressHandler creates a new AddressHandler.
 func NewAddressHandler(addresses *models.AddressModel) *AddressHandler {
 	return &AddressHandler{addresses: addresses}
 }
 
+// Create handles POST requests to add a new tracked address.
 func (h *AddressHandler) Create(w http.ResponseWriter, r *http.Request) {
 	userID := middleware.GetUserID(r.Context())
 
@@ -32,16 +36,19 @@ func (h *AddressHandler) Create(w http.ResponseWriter, r *http.Request) {
 	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
 		log.Printf("Failed to decode address request body: %v", err)
 		writeError(w, http.StatusBadRequest, "VALIDATION_ERROR", "Invalid request body")
+
 		return
 	}
 
 	if body.Address == "" {
 		writeError(w, http.StatusBadRequest, "VALIDATION_ERROR", "Address is required")
+
 		return
 	}
 
 	if !ethAddressRe.MatchString(body.Address) {
 		writeError(w, http.StatusBadRequest, "VALIDATION_ERROR", "Invalid Ethereum address format")
+
 		return
 	}
 
@@ -51,10 +58,12 @@ func (h *AddressHandler) Create(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		if strings.Contains(err.Error(), "23505") || strings.Contains(err.Error(), "unique") {
 			writeError(w, http.StatusBadRequest, "VALIDATION_ERROR", "You are already tracking this address")
+
 			return
 		}
 		log.Printf("Error creating address: %v", err)
 		writeError(w, http.StatusInternalServerError, "INTERNAL_ERROR", "Failed to create address")
+
 		return
 	}
 
@@ -62,6 +71,7 @@ func (h *AddressHandler) Create(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusCreated, addr)
 }
 
+// List handles GET requests to list all tracked addresses for the current user.
 func (h *AddressHandler) List(w http.ResponseWriter, r *http.Request) {
 	userID := middleware.GetUserID(r.Context())
 	log.Printf("User %s listing addresses", userID)
@@ -70,6 +80,7 @@ func (h *AddressHandler) List(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		log.Printf("Error listing addresses: %v", err)
 		writeError(w, http.StatusInternalServerError, "INTERNAL_ERROR", "Failed to list addresses")
+
 		return
 	}
 
@@ -81,11 +92,13 @@ func (h *AddressHandler) List(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, addresses)
 }
 
+// Remove handles DELETE requests to remove a tracked address.
 func (h *AddressHandler) Remove(w http.ResponseWriter, r *http.Request) {
 	userID := middleware.GetUserID(r.Context())
 	addressID, ok := parseIntParam(r.PathValue("addressId"))
 	if !ok {
 		writeError(w, http.StatusBadRequest, "VALIDATION_ERROR", "Invalid address ID")
+
 		return
 	}
 
@@ -95,12 +108,14 @@ func (h *AddressHandler) Remove(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		log.Printf("Error deleting address: %v", err)
 		writeError(w, http.StatusInternalServerError, "INTERNAL_ERROR", "Failed to delete address")
+
 		return
 	}
 
 	if !deleted {
 		log.Printf("Address %d not found or not owned by user", addressID)
 		writeError(w, http.StatusNotFound, "NOT_FOUND", "Address not found")
+
 		return
 	}
 

backend-go/internal/handlers/alert_event.go

@@ -11,14 +11,17 @@ import (
 	"github.com/kjannette/koin-ping/backend-go/internal/models"
 )
 
+// AlertEventHandler handles HTTP requests for alert event history.
 type AlertEventHandler struct {
 	alertEvents *models.AlertEventModel
 }
 
+// NewAlertEventHandler creates a new AlertEventHandler.
 func NewAlertEventHandler(alertEvents *models.AlertEventModel) *AlertEventHandler {
 	return &AlertEventHandler{alertEvents: alertEvents}
 }
 
+// List handles GET requests to list recent alert events for the current user.
 func (h *AlertEventHandler) List(w http.ResponseWriter, r *http.Request) {
 	userID := middleware.GetUserID(r.Context())
 
@@ -34,6 +37,7 @@ func (h *AlertEventHandler) List(w http.ResponseWriter, r *http.Request) {
 
 	if limit < 1 || limit > 100 {
 		writeError(w, http.StatusBadRequest, "VALIDATION_ERROR", "Limit must be between 1 and 100")
+
 		return
 	}
 
@@ -41,6 +45,7 @@ func (h *AlertEventHandler) List(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		log.Printf("Error listing alert events: %v", err)
 		writeError(w, http.StatusInternalServerError, "INTERNAL_ERROR", "Failed to list alert events")
+
 		return
 	}
 
@@ -67,15 +72,15 @@ func mockEvents(limit int) []domain.AlertEvent {
 			Timestamp:    time.Now().Add(-2 * time.Hour),
 		},
 		{
-			ID:           2,
+			ID:           2,           //nolint:mnd
-			AlertRuleID:  2,
+			AlertRuleID:  2,           //nolint:mnd
 			Message:      "Balance dropped below threshold: Current balance 8.2 ETH",
 			AddressLabel: &label1,
 			Timestamp:    time.Now().Add(-5 * time.Hour),
 		},
 		{
-			ID:           3,
+			ID:           3,           //nolint:mnd
-			AlertRuleID:  3,
+			AlertRuleID:  3,           //nolint:mnd
 			Message:      "Outgoing transaction detected: 2.0 ETH sent",
 			AddressLabel: &label2,
 			Timestamp:    time.Now().Add(-24 * time.Hour),
@@ -85,5 +90,6 @@ func mockEvents(limit int) []domain.AlertEvent {
 	if limit < len(mocks) {
 		return mocks[:limit]
 	}
+
 	return mocks
 }

backend-go/internal/handlers/alert_rule.go

@@ -2,6 +2,7 @@ package handlers
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"log"
 	"net/http"
@@ -13,20 +14,27 @@ import (
 	"github.com/kjannette/koin-ping/backend-go/internal/models"
 )
 
+// errThresholdFormat is returned when the threshold JSON cannot be decoded.
+var errThresholdFormat = errors.New("unsupported threshold format")
+
+// AlertRuleHandler handles HTTP requests for alert rule management.
 type AlertRuleHandler struct {
 	alertRules *models.AlertRuleModel
 	addresses  *models.AddressModel
 }
 
+// NewAlertRuleHandler creates a new AlertRuleHandler.
 func NewAlertRuleHandler(alertRules *models.AlertRuleModel, addresses *models.AddressModel) *AlertRuleHandler {
 	return &AlertRuleHandler{alertRules: alertRules, addresses: addresses}
 }
 
+// Create handles POST requests to create a new alert rule for an address.
 func (h *AlertRuleHandler) Create(w http.ResponseWriter, r *http.Request) {
 	userID := middleware.GetUserID(r.Context())
 	addressID, ok := parseIntParam(r.PathValue("addressId"))
 	if !ok {
 		writeError(w, http.StatusBadRequest, "VALIDATION_ERROR", "Invalid address ID")
+
 		return
 	}
 
@@ -37,6 +45,7 @@ func (h *AlertRuleHandler) Create(w http.ResponseWriter, r *http.Request) {
 	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
 		log.Printf("Failed to decode alert request body: %v", err)
 		writeError(w, http.StatusBadRequest, "VALIDATION_ERROR", "Invalid request body")
+
 		return
 	}
 
@@ -44,6 +53,7 @@ func (h *AlertRuleHandler) Create(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		log.Printf("Failed to parse threshold: %v", err)
 		writeError(w, http.StatusBadRequest, "VALIDATION_ERROR", "threshold must be a valid number")
+
 		return
 	}
 
@@ -51,16 +61,18 @@ func (h *AlertRuleHandler) Create(w http.ResponseWriter, r *http.Request) {
 
 	if body.Type == "" {
 		writeError(w, http.StatusBadRequest, "VALIDATION_ERROR", "Alert type is required")
+
 		return
 	}
 
 	if !domain.IsValidAlertType(body.Type) {
 		types := make([]string, len(domain.ValidAlertTypes))
 		for i, t := range domain.ValidAlertTypes {
-			types[i] = string(t)
+			types[i] = t.String()
 		}
 		writeError(w, http.StatusBadRequest, "VALIDATION_ERROR",
-			fmt.Sprintf("Invalid alert type. Must be one of: %s", strings.Join(types, ", ")))
+			"Invalid alert type. Must be one of: "+strings.Join(types, ", "))
+
 		return
 	}
 
@@ -69,6 +81,7 @@ func (h *AlertRuleHandler) Create(w http.ResponseWriter, r *http.Request) {
 		if threshold == nil || *threshold <= 0 {
 			writeError(w, http.StatusBadRequest, "VALIDATION_ERROR",
 				fmt.Sprintf("Alert type '%s' requires a positive threshold value", body.Type))
+
 			return
 		}
 	}
@@ -77,11 +90,13 @@ func (h *AlertRuleHandler) Create(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		log.Printf("Error finding address: %v", err)
 		writeError(w, http.StatusInternalServerError, "INTERNAL_ERROR", "Failed to create alert rule")
+
 		return
 	}
 	if addr == nil {
 		log.Printf("Address %d not found or not owned by user", addressID)
 		writeError(w, http.StatusNotFound, "NOT_FOUND", "Address not found")
+
 		return
 	}
 
@@ -89,6 +104,7 @@ func (h *AlertRuleHandler) Create(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		log.Printf("Error creating alert rule: %v", err)
 		writeError(w, http.StatusInternalServerError, "INTERNAL_ERROR", "Failed to create alert rule")
+
 		return
 	}
 
@@ -98,12 +114,12 @@ func (h *AlertRuleHandler) Create(w http.ResponseWriter, r *http.Request) {
 
 func parseThreshold(raw json.RawMessage) (*float64, error) {
 	if len(raw) == 0 {
-		return nil, nil
+		return nil, nil //nolint:nilnil
 	}
 
 	// Check null before number -- json.Unmarshal treats null as valid for float64 (sets to 0).
 	if string(raw) == "null" {
-		return nil, nil
+		return nil, nil //nolint:nilnil
 	}
 
 	var asNumber float64
@@ -115,23 +131,26 @@ func parseThreshold(raw json.RawMessage) (*float64, error) {
 	if err := json.Unmarshal(raw, &asString); err == nil {
 		asString = strings.TrimSpace(asString)
 		if asString == "" {
-			return nil, nil
+			return nil, nil //nolint:nilnil
 		}
 		parsed, parseErr := strconv.ParseFloat(asString, 64)
 		if parseErr != nil {
 			return nil, parseErr
 		}
+
 		return &parsed, nil
 	}
 
-	return nil, fmt.Errorf("unsupported threshold format")
+	return nil, errThresholdFormat
 }
 
+// ListByAddress handles GET requests to list alert rules for an address.
 func (h *AlertRuleHandler) ListByAddress(w http.ResponseWriter, r *http.Request) {
 	userID := middleware.GetUserID(r.Context())
 	addressID, ok := parseIntParam(r.PathValue("addressId"))
 	if !ok {
 		writeError(w, http.StatusBadRequest, "VALIDATION_ERROR", "Invalid address ID")
+
 		return
 	}
 
@@ -141,11 +160,13 @@ func (h *AlertRuleHandler) ListByAddress(w http.ResponseWriter, r *http.Request)
 	if err != nil {
 		log.Printf("Error finding address: %v", err)
 		writeError(w, http.StatusInternalServerError, "INTERNAL_ERROR", "Failed to list alerts")
+
 		return
 	}
 	if addr == nil {
 		log.Printf("Address %d not found or not owned by user", addressID)
 		writeError(w, http.StatusNotFound, "NOT_FOUND", "Address not found")
+
 		return
 	}
 
@@ -153,6 +174,7 @@ func (h *AlertRuleHandler) ListByAddress(w http.ResponseWriter, r *http.Request)
 	if err != nil {
 		log.Printf("Error listing alerts: %v", err)
 		writeError(w, http.StatusInternalServerError, "INTERNAL_ERROR", "Failed to list alerts")
+
 		return
 	}
 
@@ -164,11 +186,13 @@ func (h *AlertRuleHandler) ListByAddress(w http.ResponseWriter, r *http.Request)
 	writeJSON(w, http.StatusOK, alerts)
 }
 
+// UpdateStatus handles PATCH requests to enable or disable an alert rule.
 func (h *AlertRuleHandler) UpdateStatus(w http.ResponseWriter, r *http.Request) {
 	userID := middleware.GetUserID(r.Context())
 	alertID, ok := parseIntParam(r.PathValue("alertId"))
 	if !ok {
 		writeError(w, http.StatusBadRequest, "VALIDATION_ERROR", "Invalid alert ID")
+
 		return
 	}
 
@@ -178,6 +202,7 @@ func (h *AlertRuleHandler) UpdateStatus(w http.ResponseWriter, r *http.Request)
 	if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
 		log.Printf("Failed to decode update request body: %v", err)
 		writeError(w, http.StatusBadRequest, "VALIDATION_ERROR", "Invalid request body")
+
 		return
 	}
 
@@ -185,6 +210,7 @@ func (h *AlertRuleHandler) UpdateStatus(w http.ResponseWriter, r *http.Request)
 
 	if body.Enabled == nil {
 		writeError(w, http.StatusBadRequest, "VALIDATION_ERROR", "enabled must be a boolean value")
+
 		return
 	}
 
@@ -192,11 +218,13 @@ func (h *AlertRuleHandler) UpdateStatus(w http.ResponseWriter, r *http.Request)
 	if err != nil {
 		log.Printf("Error finding alert: %v", err)
 		writeError(w, http.StatusInternalServerError, "INTERNAL_ERROR", "Failed to update alert")
+
 		return
 	}
 	if alert == nil {
 		log.Printf("Alert %d not found or not owned by user", alertID)
 		writeError(w, http.StatusNotFound, "NOT_FOUND", "Alert rule not found")
+
 		return
 	}
 
@@ -204,6 +232,7 @@ func (h *AlertRuleHandler) UpdateStatus(w http.ResponseWriter, r *http.Request)
 	if err != nil {
 		log.Printf("Error updating alert: %v", err)
 		writeError(w, http.StatusInternalServerError, "INTERNAL_ERROR", "Failed to update alert")
+
 		return
 	}
 
@@ -211,11 +240,13 @@ func (h *AlertRuleHandler) UpdateStatus(w http.ResponseWriter, r *http.Request)
 	writeJSON(w, http.StatusOK, updated)
 }
 
+// Remove handles DELETE requests to remove an alert rule.
 func (h *AlertRuleHandler) Remove(w http.ResponseWriter, r *http.Request) {
 	userID := middleware.GetUserID(r.Context())
 	alertID, ok := parseIntParam(r.PathValue("alertId"))
 	if !ok {
 		writeError(w, http.StatusBadRequest, "VALIDATION_ERROR", "Invalid alert ID")
+
 		return
 	}
 
@@ -225,17 +256,20 @@ func (h *AlertRuleHandler) Remove(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		log.Printf("Error finding alert: %v", err)
 		writeError(w, http.StatusInternalServerError, "INTERNAL_ERROR", "Failed to delete alert")
+
 		return
 	}
 	if alert == nil {
 		log.Printf("Alert %d not found or not owned by user", alertID)
 		writeError(w, http.StatusNotFound, "NOT_FOUND", "Alert rule not found")
+
 		return
 	}
 
 	if _, err := h.alertRules.Remove(r.Context(), alertID); err != nil {
 		log.Printf("Error deleting alert: %v", err)
 		writeError(w, http.StatusInternalServerError, "INTERNAL_ERROR", "Failed to delete alert")
+
 		return
 	}
 

backend-go/internal/handlers/alert_rule_test.go

@@ -1,3 +1,4 @@
+//nolint:testpackage // parseThreshold is unexported; internal test package required
 package handlers
 
 import (
@@ -6,8 +7,13 @@ import (
 	"testing"
 )
 
+//nolint:gocognit
 func TestParseThreshold(t *testing.T) {
+	t.Parallel()
+
 	t.Run("nil/empty raw message returns nil", func(t *testing.T) {
+		t.Parallel()
+
 		val, err := parseThreshold(nil)
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
@@ -18,6 +24,8 @@ func TestParseThreshold(t *testing.T) {
 	})
 
 	t.Run("empty slice returns nil", func(t *testing.T) {
+		t.Parallel()
+
 		val, err := parseThreshold(json.RawMessage{})
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
@@ -28,6 +36,8 @@ func TestParseThreshold(t *testing.T) {
 	})
 
 	t.Run("JSON null returns nil", func(t *testing.T) {
+		t.Parallel()
+
 		val, err := parseThreshold(json.RawMessage("null"))
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
@@ -38,6 +48,8 @@ func TestParseThreshold(t *testing.T) {
 	})
 
 	t.Run("number 10 returns 10.0", func(t *testing.T) {
+		t.Parallel()
+
 		val, err := parseThreshold(json.RawMessage("10"))
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
@@ -51,6 +63,8 @@ func TestParseThreshold(t *testing.T) {
 	})
 
 	t.Run("number 0.5 returns 0.5", func(t *testing.T) {
+		t.Parallel()
+
 		val, err := parseThreshold(json.RawMessage("0.5"))
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
@@ -61,6 +75,8 @@ func TestParseThreshold(t *testing.T) {
 	})
 
 	t.Run("string '10' returns 10.0", func(t *testing.T) {
+		t.Parallel()
+
 		val, err := parseThreshold(json.RawMessage(`"10"`))
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
@@ -71,6 +87,8 @@ func TestParseThreshold(t *testing.T) {
 	})
 
 	t.Run("string '0.001' returns 0.001", func(t *testing.T) {
+		t.Parallel()
+
 		val, err := parseThreshold(json.RawMessage(`"0.001"`))
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
@@ -81,6 +99,8 @@ func TestParseThreshold(t *testing.T) {
 	})
 
 	t.Run("string with spaces '  10  ' returns 10.0", func(t *testing.T) {
+		t.Parallel()
+
 		val, err := parseThreshold(json.RawMessage(`"  10  "`))
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
@@ -91,6 +111,8 @@ func TestParseThreshold(t *testing.T) {
 	})
 
 	t.Run("empty string returns nil", func(t *testing.T) {
+		t.Parallel()
+
 		val, err := parseThreshold(json.RawMessage(`""`))
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
@@ -101,6 +123,8 @@ func TestParseThreshold(t *testing.T) {
 	})
 
 	t.Run("whitespace-only string returns nil", func(t *testing.T) {
+		t.Parallel()
+
 		val, err := parseThreshold(json.RawMessage(`"   "`))
 		if err != nil {
 			t.Fatalf("unexpected error: %v", err)
@@ -111,6 +135,8 @@ func TestParseThreshold(t *testing.T) {
 	})
 
 	t.Run("invalid string returns error", func(t *testing.T) {
+		t.Parallel()
+
 		_, err := parseThreshold(json.RawMessage(`"abc"`))
 		if err == nil {
 			t.Fatal("expected error for non-numeric string")
@@ -118,6 +144,8 @@ func TestParseThreshold(t *testing.T) {
 	})
 
 	t.Run("boolean returns error", func(t *testing.T) {
+		t.Parallel()
+
 		_, err := parseThreshold(json.RawMessage("true"))
 		if err == nil {
 			t.Fatal("expected error for boolean")
@@ -125,6 +153,8 @@ func TestParseThreshold(t *testing.T) {
 	})
 
 	t.Run("array returns error", func(t *testing.T) {
+		t.Parallel()
+
 		_, err := parseThreshold(json.RawMessage("[1,2]"))
 		if err == nil {
 			t.Fatal("expected error for array")
@@ -132,7 +162,10 @@ func TestParseThreshold(t *testing.T) {
 	})
 }
 
+//nolint:funlen
 func TestDecodeAlertBody(t *testing.T) {
+	t.Parallel()
+
 	// Verifies that the struct used in Create handler can decode all
 	// payload shapes the frontend might send.
 
@@ -183,12 +216,15 @@ func TestDecodeAlertBody(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
 			var body alertBody
 			err := json.Unmarshal([]byte(tt.payload), &body)
 			if tt.wantErr {
 				if err == nil {
 					t.Fatal("expected decode error")
 				}
+
 				return
 			}
 			if err != nil {
@@ -199,6 +235,8 @@ func TestDecodeAlertBody(t *testing.T) {
 }
 
 func TestOldStructFailsWithStringThreshold(t *testing.T) {
+	t.Parallel()
+
 	// Documents the original bug: *float64 cannot decode a string threshold.
 	type oldAlertBody struct {
 		Type      string   `json:"type"`

backend-go/internal/middleware/auth.go

@@ -1,3 +1,4 @@
+// Package middleware provides HTTP middleware for authentication and context injection.
 package middleware
 
 import (

backend-go/internal/models/address.go

@@ -2,7 +2,9 @@ package models
 
 import (
 	"context"
+	"errors"
 
+	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"github.com/kjannette/koin-ping/backend-go/internal/domain"
 )
@@ -97,7 +99,7 @@ func (m *AddressModel) FindByID(ctx context.Context, id int, userID *string) (*d
 	}
 
 	if err != nil {
-		if err.Error() == "no rows in result set" {
+		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err

backend-go/internal/models/alert_rule.go

@@ -2,7 +2,9 @@ package models
 
 import (
 	"context"
+	"errors"
 
+	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"github.com/kjannette/koin-ping/backend-go/internal/domain"
 )
@@ -21,7 +23,7 @@ func (m *AlertRuleModel) Create(ctx context.Context, addressID int, alertType do
 		`INSERT INTO alert_rules (address_id, type, threshold, enabled)
 		 VALUES ($1, $2, $3, TRUE)
 		 RETURNING id, address_id, type, threshold, enabled, created_at`,
-		addressID, string(alertType), threshold,
+		addressID, alertType.String(), threshold,
 	).Scan(&r.ID, &r.AddressID, &r.Type, &r.Threshold, &r.Enabled, &r.CreatedAt)
 	if err != nil {
 		return nil, err
@@ -75,7 +77,7 @@ func (m *AlertRuleModel) FindByID(ctx context.Context, id int, userID *string) (
 	}
 
 	if err != nil {
-		if err.Error() == "no rows in result set" {
+		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err
@@ -93,7 +95,7 @@ func (m *AlertRuleModel) UpdateEnabled(ctx context.Context, id int, enabled bool
 		id, enabled,
 	).Scan(&r.ID, &r.AddressID, &r.Type, &r.Threshold, &r.Enabled, &r.CreatedAt)
 	if err != nil {
-		if err.Error() == "no rows in result set" {
+		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err

backend-go/internal/models/checkpoint.go

@@ -2,7 +2,9 @@ package models
 
 import (
 	"context"
+	"errors"
 
+	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"github.com/kjannette/koin-ping/backend-go/internal/domain"
 )
@@ -23,7 +25,7 @@ func (m *CheckpointModel) GetLastCheckedBlock(ctx context.Context, addressID int
 		addressID,
 	).Scan(&block)
 	if err != nil {
-		if err.Error() == "no rows in result set" {
+		if errors.Is(err, pgx.ErrNoRows) {
 			return 0, false, nil
 		}
 		return 0, false, err

backend-go/internal/models/notification_config.go

@@ -2,7 +2,9 @@ package models
 
 import (
 	"context"
+	"errors"
 
+	"github.com/jackc/pgx/v5"
 	"github.com/jackc/pgx/v5/pgxpool"
 	"github.com/kjannette/koin-ping/backend-go/internal/domain"
 )
@@ -26,7 +28,7 @@ func (m *NotificationConfigModel) GetConfig(ctx context.Context, userID string)
 	).Scan(&c.UserID, &c.DiscordWebhookURL, &c.TelegramChatID, &c.TelegramBotToken,
 		&c.Email, &c.NotificationEnabled, &c.CreatedAt, &c.UpdatedAt)
 	if err != nil {
-		if err.Error() == "no rows in result set" {
+		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, nil
 		}
 		return nil, err

backend-go/internal/notifications/discord.go

@@ -9,6 +9,22 @@ import (
 	"time"
 )
 
+const (
+	// discordHTTPTimeoutSeconds is the timeout for Discord webhook requests.
+	discordHTTPTimeoutSeconds = 10
+
+	// Alert color codes for Discord embeds.
+	colorGreen  = 0x00ff00
+	colorOrange = 0xff9900
+	colorRed    = 0xff0000
+	colorBlue   = 0x0099ff
+)
+
+// discordHTTPClient is a shared HTTP client with a timeout for Discord requests.
+var discordHTTPClient = &http.Client{ //nolint:gochecknoglobals
+	Timeout: discordHTTPTimeoutSeconds * time.Second,
+}
+
 type AlertMetadata struct {
 	TxHash       string
 	AddressLabel string
@@ -73,7 +89,9 @@ func SendDiscordNotification(webhookURL, message string, meta AlertMetadata) (bo
 		return false, fmt.Errorf("marshal discord payload: %w", err)
 	}
 
-	resp, err := http.Post(webhookURL, "application/json", bytes.NewReader(body))
+	resp, err := discordHTTPClient.Post(
+		webhookURL, "application/json", bytes.NewReader(body),
+	)
 	if err != nil {
 		log.Printf("Failed to send Discord notification: %v", err)
 		return false, err
@@ -98,7 +116,9 @@ func TestDiscordWebhook(webhookURL string) (bool, error) {
 		return false, err
 	}
 
-	resp, err := http.Post(webhookURL, "application/json", bytes.NewReader(body))
+	resp, err := discordHTTPClient.Post(
+		webhookURL, "application/json", bytes.NewReader(body),
+	)
 	if err != nil {
 		log.Printf("Discord webhook test failed: %v", err)
 		return false, err
@@ -111,14 +131,14 @@ func TestDiscordWebhook(webhookURL string) (bool, error) {
 func colorForAlertType(alertType string) int {
 	switch alertType {
 	case "incoming_tx":
-		return 0x00ff00 // Green
+		return colorGreen
 	case "outgoing_tx":
-		return 0xff9900 // Orange
+		return colorOrange
 	case "large_transfer":
-		return 0xff0000 // Red
+		return colorRed
 	case "balance_below":
-		return 0xff0000 // Red
+		return colorRed
 	default:
-		return 0x0099ff // Blue
+		return colorBlue
 	}
 }

backend-go/internal/services/evaluator.go

@@ -170,7 +170,11 @@ func (s *EvaluatorService) fireAlert(ctx context.Context, rule domain.AlertRule,
 
 	// Send Discord notification (non-fatal on failure)
 	if addr != nil {
-		go s.sendNotification(ctx, addr.UserID, message, obs, addressLabel, rule, addr.Address)
+		go func() {
+			s.sendNotification(
+				ctx, addr.UserID, message, obs, addressLabel, rule, addr.Address,
+			)
+		}()
 	}
 
 	return nil

frontend/README.md

@@ -5,24 +5,27 @@ React + Vite frontend for the on-chain monitoring and alerting system.
 ## Getting Started
 
 1. Install dependencies:
-   ```bash
+
-   npm install
+    ```bash
-   ```
+    npm install
+    ```
 
 2. Run the development server:
-   ```bash
+
-   npm run dev
+    ```bash
-   ```
+    npm run dev
+    ```
 
 3. Build for production:
-   ```bash
+
-   npm run build
+    ```bash
-   ```
+    npm run build
+    ```
 
 4. Preview production build:
-   ```bash
+    ```bash
-   npm run preview
+    npm run preview
-   ```
+    ```
 
 ## Project Structure
 
@@ -34,5 +37,5 @@ React + Vite frontend for the on-chain monitoring and alerting system.
 
 ## Development
 
-The frontend runs on port 3000 and proxies API requests to the backend running on port 5000.
+The frontend runs on port 3000 and proxies API requests to the backend running
-
+on port 5000.

frontend/package.json

@@ -1,32 +1,36 @@
 {
-  "name": "frontend",
+    "name": "frontend",
-  "version": "1.0.0",
+    "version": "1.0.0",
-  "description": "koin_ping blockchain monoitor UI",
+    "description": "koin_ping blockchain monitor UI",
-  "main": "index.js",
+    "main": "index.js",
-  "scripts": {
+    "scripts": {
-    "dev": "vite",
+        "dev": "vite",
-    "build": "vite build",
+        "build": "vite build",
-    "preview": "vite preview"
+        "preview": "vite preview",
-  },
+        "test": "vite build",
-  "keywords": [
+        "lint": "prettier --check 'src/**/*.{js,jsx,ts,tsx,css}'",
-    "cryptocurrency",
+        "fmt": "prettier --write 'src/**/*.{js,jsx,ts,tsx,css}'"
-    "blockchain",
+    },
-    "blockchain event moitoring"
+    "keywords": [
-  ],
+        "cryptocurrency",
-  "author": "Steven Jannette",
+        "blockchain",
-  "license": "MIT",
+        "blockchain event monitoring"
-  "type": "module",
+    ],
-  "dependencies": {
+    "author": "Steven Jannette",
-    "firebase": "^12.7.0",
+    "license": "MIT",
-    "react": "^19.2.3",
+    "type": "module",
-    "react-dom": "^19.2.3",
+    "dependencies": {
-    "react-router-dom": "^7.11.0"
+        "firebase": "^12.7.0",
-  },
+        "react": "^19.2.3",
-  "devDependencies": {
+        "react-dom": "^19.2.3",
-    "@types/react": "^19.2.7",
+        "react-router-dom": "^7.11.0"
-    "@types/react-dom": "^19.2.3",
+    },
-    "@vitejs/plugin-react": "^5.1.2",
+    "devDependencies": {
-    "typescript": "^5.9.3",
+        "@types/react": "^19.2.7",
-    "vite": "^7.3.0"
+        "@types/react-dom": "^19.2.3",
-  }
+        "@vitejs/plugin-react": "^5.1.2",
-}
+        "prettier": "^3.8.1",
+        "typescript": "^5.9.3",
+        "vite": "^7.3.0"
+    }
+}

frontend/prettierrc

@@ -0,0 +1,4 @@
+{
+    "tabWidth": 4,
+    "proseWrap": "always"
+}

frontend/src/App.jsx

@@ -7,56 +7,71 @@ import Alerts from "./pages/Alerts";
 import AlertHistory from "./pages/AlertHistory";
 
 export default function App() {
-  const { currentUser, logout } = useAuth();
+    const { currentUser, logout } = useAuth();
 
-  // Show login/signup routes if not authenticated
+    // Show login/signup routes if not authenticated
-  if (!currentUser) {
+    if (!currentUser) {
+        return (
+            <Routes>
+                <Route path="/login" element={<Login />} />
+                <Route path="/signup" element={<Signup />} />
+                <Route path="*" element={<Navigate to="/login" />} />
+            </Routes>
+        );
+    }
+
+    // Show main app if authenticated
     return (
-      <Routes>
+        <div style={{ padding: "1rem" }}>
-        <Route path="/login" element={<Login />} />
+            <nav
-        <Route path="/signup" element={<Signup />} />
+                style={{
-        <Route path="*" element={<Navigate to="/login" />} />
+                    marginBottom: "1rem",
-      </Routes>
+                    display: "flex",
+                    justifyContent: "space-between",
+                    alignItems: "center",
+                }}
+            >
+                <div>
+                    <Link to="/addresses">Addresses</Link>
+                    {" | "}
+                    <Link to="/alerts">Alerts</Link>
+                    {" | "}
+                    <Link to="/history">History</Link>
+                </div>
+                <div
+                    style={{
+                        display: "flex",
+                        alignItems: "center",
+                        gap: "1rem",
+                    }}
+                >
+                    <span style={{ fontSize: "0.9rem", color: "#999" }}>
+                        {currentUser.email}
+                    </span>
+                    <button
+                        onClick={logout}
+                        style={{
+                            padding: "0.5rem 1rem",
+                            fontSize: "0.9rem",
+                            backgroundColor: "#333",
+                            color: "white",
+                            border: "1px solid #555",
+                            borderRadius: "4px",
+                            cursor: "pointer",
+                        }}
+                    >
+                        Logout
+                    </button>
+                </div>
+            </nav>
+
+            <Routes>
+                <Route path="/" element={<Addresses />} />
+                <Route path="/addresses" element={<Addresses />} />
+                <Route path="/alerts" element={<Alerts />} />
+                <Route path="/history" element={<AlertHistory />} />
+                <Route path="*" element={<Navigate to="/addresses" />} />
+            </Routes>
+        </div>
     );
-  }
-
-  // Show main app if authenticated
-  return (
-    <div style={{ padding: "1rem" }}>
-      <nav style={{ marginBottom: "1rem", display: "flex", justifyContent: "space-between", alignItems: "center" }}>
-        <div>
-          <Link to="/addresses">Addresses</Link>{" | "}
-          <Link to="/alerts">Alerts</Link>{" | "}
-          <Link to="/history">History</Link>
-        </div>
-        <div style={{ display: "flex", alignItems: "center", gap: "1rem" }}>
-          <span style={{ fontSize: "0.9rem", color: "#999" }}>
-            {currentUser.email}
-          </span>
-          <button
-            onClick={logout}
-            style={{
-              padding: "0.5rem 1rem",
-              fontSize: "0.9rem",
-              backgroundColor: "#333",
-              color: "white",
-              border: "1px solid #555",
-              borderRadius: "4px",
-              cursor: "pointer"
-            }}
-          >
-            Logout
-          </button>
-        </div>
-      </nav>
-
-      <Routes>
-        <Route path="/" element={<Addresses />} />
-        <Route path="/addresses" element={<Addresses />} />
-        <Route path="/alerts" element={<Alerts />} />
-        <Route path="/history" element={<AlertHistory />} />
-        <Route path="*" element={<Navigate to="/addresses" />} />
-      </Routes>
-    </div>
-  );
 }

frontend/src/api/addresses.jsx

@@ -1,7 +1,7 @@
 // API client for address management
 
-import { getAuthHeaders, getAuthHeadersSimple } from './authHeaders';
+import { getAuthHeaders, getAuthHeadersSimple } from "./authHeaders";
-import { API_BASE } from './config';
+import { API_BASE } from "./config";
 
 /**
  * Create a new blockchain address to monitor
@@ -11,35 +11,37 @@ import { API_BASE } from './config';
  * @returns {Promise<Object>} Created address with id and metadata
  */
 export async function createAddress(data) {
-  try {
+    try {
-  const headers = await getAuthHeaders();
+        const headers = await getAuthHeaders();
-  const response = await fetch(`${API_BASE}/addresses`, {
+        const response = await fetch(`${API_BASE}/addresses`, {
-    method: 'POST',
+            method: "POST",
-    headers: headers,
+            headers: headers,
-    body: JSON.stringify(data)
+            body: JSON.stringify(data),
-  });
+        });
-  
+
-  if (!response.ok) {
+        if (!response.ok) {
-      // Try to parse error response, but handle if it's not JSON
+            // Try to parse error response, but handle if it's not JSON
-      let errorMessage = 'Failed to create address';
+            let errorMessage = "Failed to create address";
-      try {
+            try {
-    const error = await response.json();
+                const error = await response.json();
-        errorMessage = error.message || errorMessage;
+                errorMessage = error.message || errorMessage;
-      } catch {
+            } catch {
-        // If JSON parse fails, use status text
+                // If JSON parse fails, use status text
-        errorMessage = `Server error: ${response.status} ${response.statusText}`;
+                errorMessage = `Server error: ${response.status} ${response.statusText}`;
-      }
+            }
-      throw new Error(errorMessage);
+            throw new Error(errorMessage);
-  }
+        }
-  
+
-  return response.json();
+        return response.json();
-  } catch (error) {
+    } catch (error) {
-    // Handle network errors
+        // Handle network errors
-    if (error.message.includes('fetch')) {
+        if (error.message.includes("fetch")) {
-      throw new Error('Cannot connect to server. Is the backend running?');
+            throw new Error(
+                "Cannot connect to server. Is the backend running?",
+            );
+        }
+        throw error;
     }
-    throw error;
-  }
 }
 
 /**
@@ -47,33 +49,35 @@ export async function createAddress(data) {
  * @returns {Promise<Array>} List of all addresses
  */
 export async function getAddresses() {
-  try {
+    try {
-  const headers = await getAuthHeadersSimple();
+        const headers = await getAuthHeadersSimple();
-  const response = await fetch(`${API_BASE}/addresses`, {
+        const response = await fetch(`${API_BASE}/addresses`, {
-    headers: headers
+            headers: headers,
-  });
+        });
-  
+
-  if (!response.ok) {
+        if (!response.ok) {
-      // Try to parse error response, but handle if it's not JSON
+            // Try to parse error response, but handle if it's not JSON
-      let errorMessage = 'Failed to fetch addresses';
+            let errorMessage = "Failed to fetch addresses";
-      try {
+            try {
-    const error = await response.json();
+                const error = await response.json();
-        errorMessage = error.message || errorMessage;
+                errorMessage = error.message || errorMessage;
-      } catch {
+            } catch {
-        // If JSON parse fails, use status text
+                // If JSON parse fails, use status text
-        errorMessage = `Server error: ${response.status} ${response.statusText}`;
+                errorMessage = `Server error: ${response.status} ${response.statusText}`;
-      }
+            }
-      throw new Error(errorMessage);
+            throw new Error(errorMessage);
-  }
+        }
-  
+
-  return response.json();
+        return response.json();
-  } catch (error) {
+    } catch (error) {
-    // Handle network errors or JSON parse errors
+        // Handle network errors or JSON parse errors
-    if (error.message.includes('fetch')) {
+        if (error.message.includes("fetch")) {
-      throw new Error('Cannot connect to server. Is the backend running?');
+            throw new Error(
+                "Cannot connect to server. Is the backend running?",
+            );
+        }
+        throw error;
     }
-    throw error;
-  }
 }
 
 /**
@@ -82,31 +86,32 @@ export async function getAddresses() {
  * @returns {Promise<void>}
  */
 export async function deleteAddress(addressId) {
-  try {
+    try {
-  const headers = await getAuthHeadersSimple();
+        const headers = await getAuthHeadersSimple();
-  const response = await fetch(`${API_BASE}/addresses/${addressId}`, {
+        const response = await fetch(`${API_BASE}/addresses/${addressId}`, {
-    method: 'DELETE',
+            method: "DELETE",
-    headers: headers
+            headers: headers,
-  });
+        });
-  
-  if (!response.ok && response.status !== 204) {
-      // Try to parse error response, but handle if it's not JSON
-      let errorMessage = 'Failed to delete address';
-      try {
-    const error = await response.json();
-        errorMessage = error.message || errorMessage;
-      } catch {
-        // If JSON parse fails, use status text
-        errorMessage = `Server error: ${response.status} ${response.statusText}`;
-      }
-      throw new Error(errorMessage);
-    }
-  } catch (error) {
-    // Handle network errors
-    if (error.message.includes('fetch')) {
-      throw new Error('Cannot connect to server. Is the backend running?');
-    }
-    throw error;
-  }
-}
 
+        if (!response.ok && response.status !== 204) {
+            // Try to parse error response, but handle if it's not JSON
+            let errorMessage = "Failed to delete address";
+            try {
+                const error = await response.json();
+                errorMessage = error.message || errorMessage;
+            } catch {
+                // If JSON parse fails, use status text
+                errorMessage = `Server error: ${response.status} ${response.statusText}`;
+            }
+            throw new Error(errorMessage);
+        }
+    } catch (error) {
+        // Handle network errors
+        if (error.message.includes("fetch")) {
+            throw new Error(
+                "Cannot connect to server. Is the backend running?",
+            );
+        }
+        throw error;
+    }
+}

frontend/src/api/alertEvents.jsx

@@ -1,35 +1,37 @@
 // API client for alert event history
 
-import { getAuthHeadersSimple } from './authHeaders';
+import { getAuthHeadersSimple } from "./authHeaders";
-import { API_BASE } from './config';
+import { API_BASE } from "./config";
 
 /**
  * Get all alert events (history)
  * @returns {Promise<Array>} List of alert events, sorted by most recent first
  */
 export async function getAlertEvents() {
-  try {
+    try {
-  const headers = await getAuthHeadersSimple();
+        const headers = await getAuthHeadersSimple();
-  const response = await fetch(`${API_BASE}/alert-events`, {
+        const response = await fetch(`${API_BASE}/alert-events`, {
-    headers: headers
+            headers: headers,
-  });
+        });
-  
+
-  if (!response.ok) {
+        if (!response.ok) {
-      let errorMessage = 'Failed to fetch alert events';
+            let errorMessage = "Failed to fetch alert events";
-      try {
+            try {
-    const error = await response.json();
+                const error = await response.json();
-        errorMessage = error.message || errorMessage;
+                errorMessage = error.message || errorMessage;
-      } catch {
+            } catch {
-        errorMessage = `Server error: ${response.status} ${response.statusText}`;
+                errorMessage = `Server error: ${response.status} ${response.statusText}`;
-      }
+            }
-      throw new Error(errorMessage);
+            throw new Error(errorMessage);
-  }
+        }
-  
+
-  return response.json();
+        return response.json();
-  } catch (error) {
+    } catch (error) {
-    if (error.message.includes('fetch')) {
+        if (error.message.includes("fetch")) {
-      throw new Error('Cannot connect to server. Is the backend running?');
+            throw new Error(
+                "Cannot connect to server. Is the backend running?",
+            );
+        }
+        throw error;
     }
-    throw error;
-  }
 }

frontend/src/api/alerts.jsx

@@ -1,16 +1,16 @@
 // API client for alert rule management
 
-import { getAuthHeaders, getAuthHeadersSimple } from './authHeaders';
+import { getAuthHeaders, getAuthHeadersSimple } from "./authHeaders";
-import { API_BASE } from './config';
+import { API_BASE } from "./config";
 
 /**
  * Alert types supported by the system
  */
 export const ALERT_TYPES = {
-  INCOMING_TX: 'incoming_tx',
+    INCOMING_TX: "incoming_tx",
-  OUTGOING_TX: 'outgoing_tx',
+    OUTGOING_TX: "outgoing_tx",
-  LARGE_TRANSFER: 'large_transfer',
+    LARGE_TRANSFER: "large_transfer",
-  BALANCE_BELOW: 'balance_below'
+    BALANCE_BELOW: "balance_below",
 };
 
 /**
@@ -22,32 +22,37 @@ export const ALERT_TYPES = {
  * @returns {Promise<Object>} Created alert rule
  */
 export async function createAlert(addressId, data) {
-  try {
+    try {
-  const headers = await getAuthHeaders();
+        const headers = await getAuthHeaders();
-  const response = await fetch(`${API_BASE}/addresses/${addressId}/alerts`, {
+        const response = await fetch(
-    method: 'POST',
+            `${API_BASE}/addresses/${addressId}/alerts`,
-    headers: headers,
+            {
-    body: JSON.stringify(data)
+                method: "POST",
-  });
+                headers: headers,
-  
+                body: JSON.stringify(data),
-  if (!response.ok) {
+            },
-      let errorMessage = 'Failed to create alert rule';
+        );
-      try {
+
-    const error = await response.json();
+        if (!response.ok) {
-        errorMessage = error.message || errorMessage;
+            let errorMessage = "Failed to create alert rule";
-      } catch {
+            try {
-        errorMessage = `Server error: ${response.status} ${response.statusText}`;
+                const error = await response.json();
-      }
+                errorMessage = error.message || errorMessage;
-      throw new Error(errorMessage);
+            } catch {
-  }
+                errorMessage = `Server error: ${response.status} ${response.statusText}`;
-  
+            }
-  return response.json();
+            throw new Error(errorMessage);
-  } catch (error) {
+        }
-    if (error.message.includes('fetch')) {
+
-      throw new Error('Cannot connect to server. Is the backend running?');
+        return response.json();
+    } catch (error) {
+        if (error.message.includes("fetch")) {
+            throw new Error(
+                "Cannot connect to server. Is the backend running?",
+            );
+        }
+        throw error;
     }
-    throw error;
-  }
 }
 
 /**
@@ -56,30 +61,35 @@ export async function createAlert(addressId, data) {
  * @returns {Promise<Array>} List of alert rules
  */
 export async function getAlerts(addressId) {
-  try {
+    try {
-  const headers = await getAuthHeadersSimple();
+        const headers = await getAuthHeadersSimple();
-  const response = await fetch(`${API_BASE}/addresses/${addressId}/alerts`, {
+        const response = await fetch(
-    headers: headers
+            `${API_BASE}/addresses/${addressId}/alerts`,
-  });
+            {
-  
+                headers: headers,
-  if (!response.ok) {
+            },
-      let errorMessage = 'Failed to fetch alert rules';
+        );
-      try {
+
-    const error = await response.json();
+        if (!response.ok) {
-        errorMessage = error.message || errorMessage;
+            let errorMessage = "Failed to fetch alert rules";
-      } catch {
+            try {
-        errorMessage = `Server error: ${response.status} ${response.statusText}`;
+                const error = await response.json();
-      }
+                errorMessage = error.message || errorMessage;
-      throw new Error(errorMessage);
+            } catch {
-  }
+                errorMessage = `Server error: ${response.status} ${response.statusText}`;
-  
+            }
-  return response.json();
+            throw new Error(errorMessage);
-  } catch (error) {
+        }
-    if (error.message.includes('fetch')) {
+
-      throw new Error('Cannot connect to server. Is the backend running?');
+        return response.json();
+    } catch (error) {
+        if (error.message.includes("fetch")) {
+            throw new Error(
+                "Cannot connect to server. Is the backend running?",
+            );
+        }
+        throw error;
     }
-    throw error;
-  }
 }
 
 /**
@@ -89,32 +99,34 @@ export async function getAlerts(addressId) {
  * @returns {Promise<Object>} Updated alert rule
  */
 export async function updateAlertStatus(alertId, enabled) {
-  try {
+    try {
-  const headers = await getAuthHeaders();
+        const headers = await getAuthHeaders();
-  const response = await fetch(`${API_BASE}/alerts/${alertId}`, {
+        const response = await fetch(`${API_BASE}/alerts/${alertId}`, {
-    method: 'PATCH',
+            method: "PATCH",
-    headers: headers,
+            headers: headers,
-    body: JSON.stringify({ enabled })
+            body: JSON.stringify({ enabled }),
-  });
+        });
-  
+
-  if (!response.ok) {
+        if (!response.ok) {
-      let errorMessage = 'Failed to update alert rule';
+            let errorMessage = "Failed to update alert rule";
-      try {
+            try {
-    const error = await response.json();
+                const error = await response.json();
-        errorMessage = error.message || errorMessage;
+                errorMessage = error.message || errorMessage;
-      } catch {
+            } catch {
-        errorMessage = `Server error: ${response.status} ${response.statusText}`;
+                errorMessage = `Server error: ${response.status} ${response.statusText}`;
-      }
+            }
-      throw new Error(errorMessage);
+            throw new Error(errorMessage);
-  }
+        }
-  
+
-  return response.json();
+        return response.json();
-  } catch (error) {
+    } catch (error) {
-    if (error.message.includes('fetch')) {
+        if (error.message.includes("fetch")) {
-      throw new Error('Cannot connect to server. Is the backend running?');
+            throw new Error(
+                "Cannot connect to server. Is the backend running?",
+            );
+        }
+        throw error;
     }
-    throw error;
-  }
 }
 
 /**
@@ -123,27 +135,29 @@ export async function updateAlertStatus(alertId, enabled) {
  * @returns {Promise<void>}
  */
 export async function deleteAlert(alertId) {
-  try {
+    try {
-  const headers = await getAuthHeadersSimple();
+        const headers = await getAuthHeadersSimple();
-  const response = await fetch(`${API_BASE}/alerts/${alertId}`, {
+        const response = await fetch(`${API_BASE}/alerts/${alertId}`, {
-    method: 'DELETE',
+            method: "DELETE",
-    headers: headers
+            headers: headers,
-  });
+        });
-  
+
-  if (!response.ok && response.status !== 204) {
+        if (!response.ok && response.status !== 204) {
-      let errorMessage = 'Failed to delete alert rule';
+            let errorMessage = "Failed to delete alert rule";
-      try {
+            try {
-    const error = await response.json();
+                const error = await response.json();
-        errorMessage = error.message || errorMessage;
+                errorMessage = error.message || errorMessage;
-      } catch {
+            } catch {
-        errorMessage = `Server error: ${response.status} ${response.statusText}`;
+                errorMessage = `Server error: ${response.status} ${response.statusText}`;
-      }
+            }
-      throw new Error(errorMessage);
+            throw new Error(errorMessage);
+        }
+    } catch (error) {
+        if (error.message.includes("fetch")) {
+            throw new Error(
+                "Cannot connect to server. Is the backend running?",
+            );
+        }
+        throw error;
     }
-  } catch (error) {
-    if (error.message.includes('fetch')) {
-      throw new Error('Cannot connect to server. Is the backend running?');
-    }
-    throw error;
-  }
 }

frontend/src/api/authHeaders.js

@@ -1,30 +1,30 @@
 /**
  * Auth Headers Helper
- * 
+ *
  * Provides authentication headers for API calls
  * Includes Firebase ID token in Authorization header
  */
 
-import { auth } from '../firebase/config';
+import { auth } from "../firebase/config";
 
 /**
  * Get headers with authentication token
  * @returns {Promise<Object>} Headers object with Authorization
  */
 export async function getAuthHeaders() {
-  const currentUser = auth.currentUser;
+    const currentUser = auth.currentUser;
-  
-  if (!currentUser) {
-    throw new Error('No authenticated user');
-  }
 
-  // Get Firebase ID token
+    if (!currentUser) {
-  const token = await currentUser.getIdToken();
+        throw new Error("No authenticated user");
+    }
 
-  return {
+    // Get Firebase ID token
-    'Content-Type': 'application/json',
+    const token = await currentUser.getIdToken();
-    'Authorization': `Bearer ${token}`
+
-  };
+    return {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+    };
 }
 
 /**
@@ -32,16 +32,15 @@ export async function getAuthHeaders() {
  * @returns {Promise<Object>} Headers object with Authorization
  */
 export async function getAuthHeadersSimple() {
-  const currentUser = auth.currentUser;
+    const currentUser = auth.currentUser;
-  
-  if (!currentUser) {
-    throw new Error('No authenticated user');
-  }
 
-  const token = await currentUser.getIdToken();
+    if (!currentUser) {
+        throw new Error("No authenticated user");
+    }
 
-  return {
+    const token = await currentUser.getIdToken();
-    'Authorization': `Bearer ${token}`
+
-  };
+    return {
+        Authorization: `Bearer ${token}`,
+    };
 }
-

frontend/src/api/config.js

@@ -1 +1 @@
-export const API_BASE = import.meta.env.VITE_API_BASE || '/v1';
+export const API_BASE = import.meta.env.VITE_API_BASE || "/v1";

frontend/src/api/notificationConfig.jsx

@@ -1,37 +1,39 @@
 // API client for notification configuration
 
-import { getAuthHeaders } from './authHeaders';
+import { getAuthHeaders } from "./authHeaders";
-import { API_BASE } from './config';
+import { API_BASE } from "./config";
 
 /**
  * Get notification configuration for current user
  * @returns {Promise<Object>} Notification config
  */
 export async function getNotificationConfig() {
-  try {
+    try {
-    const headers = await getAuthHeaders();
+        const headers = await getAuthHeaders();
-    const response = await fetch(`${API_BASE}/notification-config`, {
+        const response = await fetch(`${API_BASE}/notification-config`, {
-      headers: headers
+            headers: headers,
-    });
+        });
-    
+
-    if (!response.ok) {
+        if (!response.ok) {
-      let errorMessage = 'Failed to fetch notification config';
+            let errorMessage = "Failed to fetch notification config";
-      try {
+            try {
-        const error = await response.json();
+                const error = await response.json();
-        errorMessage = error.message || errorMessage;
+                errorMessage = error.message || errorMessage;
-      } catch {
+            } catch {
-        errorMessage = `Server error: ${response.status} ${response.statusText}`;
+                errorMessage = `Server error: ${response.status} ${response.statusText}`;
-      }
+            }
-      throw new Error(errorMessage);
+            throw new Error(errorMessage);
+        }
+
+        return response.json();
+    } catch (error) {
+        if (error.message.includes("fetch")) {
+            throw new Error(
+                "Cannot connect to server. Is the backend running?",
+            );
+        }
+        throw error;
     }
-    
-    return response.json();
-  } catch (error) {
-    if (error.message.includes('fetch')) {
-      throw new Error('Cannot connect to server. Is the backend running?');
-    }
-    throw error;
-  }
 }
 
 /**
@@ -44,32 +46,34 @@ export async function getNotificationConfig() {
  * @returns {Promise<Object>} Updated config
  */
 export async function updateNotificationConfig(config) {
-  try {
+    try {
-    const headers = await getAuthHeaders();
+        const headers = await getAuthHeaders();
-    const response = await fetch(`${API_BASE}/notification-config`, {
+        const response = await fetch(`${API_BASE}/notification-config`, {
-      method: 'PUT',
+            method: "PUT",
-      headers: headers,
+            headers: headers,
-      body: JSON.stringify(config)
+            body: JSON.stringify(config),
-    });
+        });
-    
+
-    if (!response.ok) {
+        if (!response.ok) {
-      let errorMessage = 'Failed to update notification config';
+            let errorMessage = "Failed to update notification config";
-      try {
+            try {
-        const error = await response.json();
+                const error = await response.json();
-        errorMessage = error.message || errorMessage;
+                errorMessage = error.message || errorMessage;
-      } catch {
+            } catch {
-        errorMessage = `Server error: ${response.status} ${response.statusText}`;
+                errorMessage = `Server error: ${response.status} ${response.statusText}`;
-      }
+            }
-      throw new Error(errorMessage);
+            throw new Error(errorMessage);
+        }
+
+        return response.json();
+    } catch (error) {
+        if (error.message.includes("fetch")) {
+            throw new Error(
+                "Cannot connect to server. Is the backend running?",
+            );
+        }
+        throw error;
     }
-    
-    return response.json();
-  } catch (error) {
-    if (error.message.includes('fetch')) {
-      throw new Error('Cannot connect to server. Is the backend running?');
-    }
-    throw error;
-  }
 }
 
 /**
@@ -79,21 +83,21 @@ export async function updateNotificationConfig(config) {
  * @returns {Promise<boolean>} True if test successful
  */
 export async function testDiscordWebhook(webhookUrl) {
-  try {
+    try {
-    const payload = {
+        const payload = {
-      content: 'Koin Ping test notification - Your Discord webhook is configured correctly!',
+            content:
-    };
+                "Koin Ping test notification - Your Discord webhook is configured correctly!",
+        };
 
-    const response = await fetch(webhookUrl, {
+        const response = await fetch(webhookUrl, {
-      method: 'POST',
+            method: "POST",
-      headers: { 'Content-Type': 'application/json' },
+            headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(payload)
+            body: JSON.stringify(payload),
-    });
+        });
 
-    return response.ok;
+        return response.ok;
-  } catch (error) {
+    } catch (error) {
-    console.error('Discord webhook test failed:', error);
+        console.error("Discord webhook test failed:", error);
-    return false;
+        return false;
-  }
+    }
 }
-

frontend/src/api/status.jsx

@@ -1,18 +1,18 @@
 // API client for system status
 
-import { API_BASE } from './config';
+import { API_BASE } from "./config";
 
 /**
  * Get system status including latest processed block and health
  * @returns {Promise<Object>} System status
  */
 export async function getSystemStatus() {
-  const response = await fetch(`${API_BASE}/status`);
+    const response = await fetch(`${API_BASE}/status`);
-  
+
-  if (!response.ok) {
+    if (!response.ok) {
-    const error = await response.json();
+        const error = await response.json();
-    throw new Error(error.message || 'Failed to fetch system status');
+        throw new Error(error.message || "Failed to fetch system status");
-  }
+    }
-  
+
-  return response.json();
+    return response.json();
 }

frontend/src/components/AddressForm.jsx

@@ -3,43 +3,43 @@ import Input from "./Input";
 import Button from "./Button";
 
 export default function AddressForm({ onSubmit }) {
-  const [address, setAddress] = useState("");
+    const [address, setAddress] = useState("");
-  const [label, setLabel] = useState("");
+    const [label, setLabel] = useState("");
 
-  const canSubmit = address.trim().length > 0;
+    const canSubmit = address.trim().length > 0;
 
-  function handleSubmit(e) {
+    function handleSubmit(e) {
-    e.preventDefault();
+        e.preventDefault();
-    if (!canSubmit) return;
+        if (!canSubmit) return;
 
-    onSubmit({
+        onSubmit({
-      address: address.trim(),
+            address: address.trim(),
-      label: label.trim(),
+            label: label.trim(),
-    });
+        });
 
-    setAddress("");
+        setAddress("");
-    setLabel("");
+        setLabel("");
-  }
+    }
 
-  return (
+    return (
-    <form onSubmit={handleSubmit}>
+        <form onSubmit={handleSubmit}>
-      <Input
+            <Input
-        label="Blockchain Address"
+                label="Blockchain Address"
-        value={address}
+                value={address}
-        onChange={setAddress}
+                onChange={setAddress}
-        placeholder="0x..."
+                placeholder="0x..."
-      />
+            />
 
-      <Input
+            <Input
-        label="Label (optional)"
+                label="Label (optional)"
-        value={label}
+                value={label}
-        onChange={setLabel}
+                onChange={setLabel}
-        placeholder="Treasury, Cold Wallet, etc."
+                placeholder="Treasury, Cold Wallet, etc."
-      />
+            />
 
-      <Button type="submit" disabled={!canSubmit}>
+            <Button type="submit" disabled={!canSubmit}>
-        Add Address
+                Add Address
-      </Button>
+            </Button>
-    </form>
+        </form>
-  );
+    );
 }

frontend/src/components/AlertForm.jsx

@@ -3,69 +3,69 @@ import Input from "./Input";
 import Button from "./Button";
 
 const ALERT_TYPES = [
-  { value: "incoming_tx", label: "Incoming transaction" },
+    { value: "incoming_tx", label: "Incoming transaction" },
-  { value: "outgoing_tx", label: "Outgoing transaction" },
+    { value: "outgoing_tx", label: "Outgoing transaction" },
-  { value: "large_transfer", label: "Large transfer" },
+    { value: "large_transfer", label: "Large transfer" },
-  { value: "balance_below", label: "Balance below threshold" },
+    { value: "balance_below", label: "Balance below threshold" },
 ];
 
 export default function AlertForm({ onSubmit }) {
-  const [type, setType] = useState("incoming_tx");
+    const [type, setType] = useState("incoming_tx");
-  const [threshold, setThreshold] = useState("");
+    const [threshold, setThreshold] = useState("");
 
-  const needsThreshold =
+    const needsThreshold =
-    type === "large_transfer" || type === "balance_below";
+        type === "large_transfer" || type === "balance_below";
 
-  const canSubmit = needsThreshold
+    const canSubmit = needsThreshold
-    ? threshold.trim() !== "" && 
+        ? threshold.trim() !== "" &&
-      !isNaN(Number(threshold)) && 
+          !isNaN(Number(threshold)) &&
-      Number(threshold) > 0
+          Number(threshold) > 0
-    : true;
+        : true;
 
-  function handleSubmit(e) {
+    function handleSubmit(e) {
-    e.preventDefault();
+        e.preventDefault();
-    if (!canSubmit) return;
+        if (!canSubmit) return;
 
-    onSubmit({
+        onSubmit({
-      type,
+            type,
-      threshold: needsThreshold ? Number(threshold) : undefined,
+            threshold: needsThreshold ? Number(threshold) : undefined,
-    });
+        });
 
-    setThreshold("");
+        setThreshold("");
-  }
+    }
 
-  return (
+    return (
-    <form onSubmit={handleSubmit}>
+        <form onSubmit={handleSubmit}>
-      <div style={{ marginBottom: "1rem" }}>
+            <div style={{ marginBottom: "1rem" }}>
-        {ALERT_TYPES.map((opt) => (
+                {ALERT_TYPES.map((opt) => (
-          <label key={opt.value} style={{ display: "block" }}>
+                    <label key={opt.value} style={{ display: "block" }}>
-            <input
+                        <input
-              type="radio"
+                            type="radio"
-              name="alertType"
+                            name="alertType"
-              value={opt.value}
+                            value={opt.value}
-              checked={type === opt.value}
+                            checked={type === opt.value}
-              onChange={() => setType(opt.value)}
+                            onChange={() => setType(opt.value)}
-            />
+                        />{" "}
-            {" "}{opt.label}
+                        {opt.label}
-          </label>
+                    </label>
-        ))}
+                ))}
-      </div>
+            </div>
 
-      {needsThreshold && (
+            {needsThreshold && (
-        <Input
+                <Input
-          label="Amount (ETH)"
+                    label="Amount (ETH)"
-          type="number"
+                    type="number"
-          step="0.000001"
+                    step="0.000001"
-          min="0"
+                    min="0"
-          value={threshold}
+                    value={threshold}
-          onChange={setThreshold}
+                    onChange={setThreshold}
-          placeholder="e.g. 10"
+                    placeholder="e.g. 10"
-        />
+                />
-      )}
+            )}
 
-      <Button type="submit" disabled={!canSubmit}>
+            <Button type="submit" disabled={!canSubmit}>
-        Create Alert
+                Create Alert
-      </Button>
+            </Button>
-    </form>
+        </form>
-  );
+    );
 }

frontend/src/components/Button.jsx

@@ -3,21 +3,20 @@ export default function Button({
     onClick,
     disabled = false,
     type = "button",
-  }) {
+}) {
     return (
-      <button
+        <button
-        type={type}
+            type={type}
-        onClick={onClick}
+            onClick={onClick}
-        disabled={disabled}
+            disabled={disabled}
-        style={{
+            style={{
-          padding: "0.5rem 1rem",
+                padding: "0.5rem 1rem",
-          fontSize: "1rem",
+                fontSize: "1rem",
-          cursor: disabled ? "not-allowed" : "pointer",
+                cursor: disabled ? "not-allowed" : "pointer",
-          opacity: disabled ? 0.6 : 1,
+                opacity: disabled ? 0.6 : 1,
-        }}
+            }}
-      >
+        >
-        {children}
+            {children}
-      </button>
+        </button>
     );
-  }
+}
-  

frontend/src/components/Input.jsx

@@ -7,27 +7,26 @@ export default function Input({
     step,
     min,
     disabled = false,
-  }) {
+}) {
     return (
-      <label style={{ display: "block", marginBottom: "1rem" }}>
+        <label style={{ display: "block", marginBottom: "1rem" }}>
-        <div style={{ marginBottom: "0.25rem", fontSize: "0.9rem" }}>
+            <div style={{ marginBottom: "0.25rem", fontSize: "0.9rem" }}>
-          {label}
+                {label}
-        </div>
+            </div>
-        <input
+            <input
-          type={type}
+                type={type}
-          value={value}
+                value={value}
-          placeholder={placeholder}
+                placeholder={placeholder}
-          step={step}
+                step={step}
-          min={min}
+                min={min}
-          disabled={disabled}
+                disabled={disabled}
-          onChange={(e) => onChange(e.target.value)}
+                onChange={(e) => onChange(e.target.value)}
-          style={{
+                style={{
-            width: "100%",
+                    width: "100%",
-            padding: "0.5rem",
+                    padding: "0.5rem",
-            fontSize: "1rem",
+                    fontSize: "1rem",
-          }}
+                }}
-        />
+            />
-      </label>
+        </label>
     );
-  }
+}
-  

frontend/src/contexts/AuthContext.jsx

@@ -1,17 +1,17 @@
 /**
  * AuthContext - Firebase Authentication State Management
- * 
+ *
  * Provides authentication state and methods throughout the app
  */
 
-import { createContext, useContext, useEffect, useState } from 'react';
+import { createContext, useContext, useEffect, useState } from "react";
-import { 
+import {
-  createUserWithEmailAndPassword,
+    createUserWithEmailAndPassword,
-  signInWithEmailAndPassword,
+    signInWithEmailAndPassword,
-  signOut,
+    signOut,
-  onAuthStateChanged
+    onAuthStateChanged,
-} from 'firebase/auth';
+} from "firebase/auth";
-import { auth } from '../firebase/config';
+import { auth } from "../firebase/config";
 
 const AuthContext = createContext();
 
@@ -20,88 +20,95 @@ const AuthContext = createContext();
  * @returns {Object} Auth context value
  */
 export function useAuth() {
-  const context = useContext(AuthContext);
+    const context = useContext(AuthContext);
-  if (!context) {
+    if (!context) {
-    throw new Error('useAuth must be used within AuthProvider');
+        throw new Error("useAuth must be used within AuthProvider");
-  }
+    }
-  return context;
+    return context;
 }
 
 /**
  * AuthProvider - Wraps app and provides auth state
  */
 export function AuthProvider({ children }) {
-  const [currentUser, setCurrentUser] = useState(null);
+    const [currentUser, setCurrentUser] = useState(null);
-  const [loading, setLoading] = useState(true);
+    const [loading, setLoading] = useState(true);
-  const [error, setError] = useState(null);
+    const [error, setError] = useState(null);
 
-  /**
+    /**
-   * Sign up with email and password
+     * Sign up with email and password
-   */
+     */
-  async function signup(email, password) {
+    async function signup(email, password) {
-    try {
+        try {
-      setError(null);
+            setError(null);
-      const result = await createUserWithEmailAndPassword(auth, email, password);
+            const result = await createUserWithEmailAndPassword(
-      return result.user;
+                auth,
-    } catch (err) {
+                email,
-      setError(err.message);
+                password,
-      throw err;
+            );
+            return result.user;
+        } catch (err) {
+            setError(err.message);
+            throw err;
+        }
     }
-  }
 
-  /**
+    /**
-   * Log in with email and password
+     * Log in with email and password
-   */
+     */
-  async function login(email, password) {
+    async function login(email, password) {
-    try {
+        try {
-      setError(null);
+            setError(null);
-      const result = await signInWithEmailAndPassword(auth, email, password);
+            const result = await signInWithEmailAndPassword(
-      return result.user;
+                auth,
-    } catch (err) {
+                email,
-      setError(err.message);
+                password,
-      throw err;
+            );
+            return result.user;
+        } catch (err) {
+            setError(err.message);
+            throw err;
+        }
     }
-  }
 
-  /**
+    /**
-   * Log out current user
+     * Log out current user
-   */
+     */
-  async function logout() {
+    async function logout() {
-    try {
+        try {
-      setError(null);
+            setError(null);
-      await signOut(auth);
+            await signOut(auth);
-    } catch (err) {
+        } catch (err) {
-      setError(err.message);
+            setError(err.message);
-      throw err;
+            throw err;
+        }
     }
-  }
 
-  /**
+    /**
-   * Listen for auth state changes
+     * Listen for auth state changes
-   */
+     */
-  useEffect(() => {
+    useEffect(() => {
-    const unsubscribe = onAuthStateChanged(auth, (user) => {
+        const unsubscribe = onAuthStateChanged(auth, (user) => {
-      setCurrentUser(user);
+            setCurrentUser(user);
-      setLoading(false);
+            setLoading(false);
-    });
+        });
 
-    // Cleanup subscription
+        // Cleanup subscription
-    return unsubscribe;
+        return unsubscribe;
-  }, []);
+    }, []);
 
-  const value = {
+    const value = {
-    currentUser,
+        currentUser,
-    signup,
+        signup,
-    login,
+        login,
-    logout,
+        logout,
-    error,
+        error,
-    loading
+        loading,
-  };
+    };
 
-  return (
+    return (
-    <AuthContext.Provider value={value}>
+        <AuthContext.Provider value={value}>
-      {!loading && children}
+            {!loading && children}
-    </AuthContext.Provider>
+        </AuthContext.Provider>
-  );
+    );
 }
-

frontend/src/firebase/config.js

@@ -1,6 +1,5 @@
-
+import { initializeApp } from "firebase/app";
-import { initializeApp } from 'firebase/app';
+import { getAuth } from "firebase/auth";
-import { getAuth } from 'firebase/auth';
 import {
     firebaseApiKey,
     firebaseAuthDomain,
@@ -8,9 +7,8 @@ import {
     firebaseStorageBucket,
     firebaseMessagingSenderId,
     firebaseAppId,
-    firebaseMeasurementId
+    firebaseMeasurementId,
-} from '../secrets.js';
+} from "../secrets.js";
-
 
 const firebaseConfig = {
     apiKey: firebaseApiKey,
@@ -19,12 +17,11 @@ const firebaseConfig = {
     storageBucket: firebaseStorageBucket,
     messagingSenderId: firebaseMessagingSenderId,
     appId: firebaseAppId,
-    measurementId: firebaseMeasurementId
+    measurementId: firebaseMeasurementId,
-  };
+};
 
 const app = initializeApp(firebaseConfig);
 
 export const auth = getAuth(app);
 
 export default app;
-

frontend/src/main.jsx

@@ -5,11 +5,11 @@ import { AuthProvider } from "./contexts/AuthContext";
 import App from "./App";
 
 ReactDOM.createRoot(document.getElementById("root")).render(
-  <React.StrictMode>
+    <React.StrictMode>
-    <BrowserRouter>
+        <BrowserRouter>
-      <AuthProvider>
+            <AuthProvider>
-        <App />
+                <App />
-      </AuthProvider>
+            </AuthProvider>
-    </BrowserRouter>
+        </BrowserRouter>
-  </React.StrictMode>
+    </React.StrictMode>,
 );

frontend/src/pages/Addresses.jsx

@@ -3,81 +3,91 @@ import AddressForm from "../components/AddressForm";
 import { getAddresses, createAddress } from "../api/addresses";
 
 export default function Addresses() {
-  const [addresses, setAddresses] = useState([]);
+    const [addresses, setAddresses] = useState([]);
-  const [loading, setLoading] = useState(true);
+    const [loading, setLoading] = useState(true);
-  const [error, setError] = useState(null);
+    const [error, setError] = useState(null);
 
-  // Load addresses on mount
+    // Load addresses on mount
-  useEffect(() => {
+    useEffect(() => {
-    async function fetchAddresses() {
+        async function fetchAddresses() {
-      try {
+            try {
-        setLoading(true);
+                setLoading(true);
-        const data = await getAddresses();
+                const data = await getAddresses();
-        setAddresses(data);
+                setAddresses(data);
-      } catch (err) {
+            } catch (err) {
-        setError(err.message);
+                setError(err.message);
-        console.error("Failed to fetch addresses:", err);
+                console.error("Failed to fetch addresses:", err);
-      } finally {
+            } finally {
-        setLoading(false);
+                setLoading(false);
-      }
+            }
+        }
+
+        fetchAddresses();
+    }, []);
+
+    // Handle new address submission
+    async function handleAddressSubmit(data) {
+        try {
+            const newAddress = await createAddress(data);
+            // Append new address to state
+            setAddresses((prev) => [...prev, newAddress]);
+            setError(null); // Clear any previous errors
+        } catch (err) {
+            setError(err.message);
+            console.error("Failed to create address:", err);
+        }
     }
 
-    fetchAddresses();
+    return (
-  }, []);
+        <div style={{ maxWidth: "800px", margin: "0 auto", padding: "2rem" }}>
+            <h1>Tracked Addresses</h1>
 
-  // Handle new address submission
+            <div style={{ marginBottom: "2rem" }}>
-  async function handleAddressSubmit(data) {
+                <AddressForm onSubmit={handleAddressSubmit} />
-    try {
+            </div>
-      const newAddress = await createAddress(data);
-      // Append new address to state
-      setAddresses((prev) => [...prev, newAddress]);
-      setError(null); // Clear any previous errors
-    } catch (err) {
-      setError(err.message);
-      console.error("Failed to create address:", err);
-    }
-  }
 
-  return (
+            <div>
-    <div style={{ maxWidth: "800px", margin: "0 auto", padding: "2rem" }}>
+                <h2>Existing Addresses</h2>
-      <h1>Tracked Addresses</h1>
+                {loading && <p>Loading addresses...</p>}
-
+                {error && <p style={{ color: "red" }}>Error: {error}</p>}
-      <div style={{ marginBottom: "2rem" }}>
+                {!loading && !error && addresses.length === 0 && (
-        <AddressForm onSubmit={handleAddressSubmit} />
+                    <p style={{ color: "#666" }}>
-      </div>
+                        No addresses tracked yet. Add one above to get started.
-
+                    </p>
-      <div>
+                )}
-        <h2>Existing Addresses</h2>
+                {addresses.length > 0 && (
-        {loading && <p>Loading addresses...</p>}
+                    <ul style={{ listStyle: "none", padding: 0 }}>
-        {error && <p style={{ color: "red" }}>Error: {error}</p>}
+                        {addresses.map((addr, index) => (
-        {!loading && !error && addresses.length === 0 && (
+                            <li
-          <p style={{ color: "#666" }}>
+                                key={addr.id || index}
-            No addresses tracked yet. Add one above to get started.
+                                style={{
-          </p>
+                                    padding: "1rem",
-        )}
+                                    marginBottom: "0.5rem",
-        {addresses.length > 0 && (
+                                    border: "1px solid #ddd",
-          <ul style={{ listStyle: "none", padding: 0 }}>
+                                    borderRadius: "4px",
-            {addresses.map((addr, index) => (
+                                }}
-              <li
+                            >
-                key={addr.id || index}
+                                <div
-                style={{
+                                    style={{
-                  padding: "1rem",
+                                        fontWeight: "bold",
-                  marginBottom: "0.5rem",
+                                        marginBottom: "0.25rem",
-                  border: "1px solid #ddd",
+                                    }}
-                  borderRadius: "4px",
+                                >
-                }}
+                                    {addr.label || "Unlabeled"}
-              >
+                                </div>
-                <div style={{ fontWeight: "bold", marginBottom: "0.25rem" }}>
+                                <div
-                  {addr.label || "Unlabeled"}
+                                    style={{
-                </div>
+                                        fontFamily: "monospace",
-                <div style={{ fontFamily: "monospace", fontSize: "0.9rem" }}>
+                                        fontSize: "0.9rem",
-                  {addr.address}
+                                    }}
-                </div>
+                                >
-              </li>
+                                    {addr.address}
-            ))}
+                                </div>
-          </ul>
+                            </li>
-        )}
+                        ))}
-      </div>
+                    </ul>
-    </div>
+                )}
-  );
+            </div>
+        </div>
+    );
 }

frontend/src/pages/AlertHistory.jsx

@@ -2,73 +2,83 @@ import { useState, useEffect } from "react";
 import { getAlertEvents } from "../api/alertEvents";
 
 export default function AlertHistory() {
-  const [alertEvents, setAlertEvents] = useState([]);
+    const [alertEvents, setAlertEvents] = useState([]);
-  const [loading, setLoading] = useState(true);
+    const [loading, setLoading] = useState(true);
-  const [error, setError] = useState(null);
+    const [error, setError] = useState(null);
 
-  // Fetch alert events on mount
+    // Fetch alert events on mount
-  useEffect(() => {
+    useEffect(() => {
-    async function fetchAlertEvents() {
+        async function fetchAlertEvents() {
-      try {
+            try {
-        setLoading(true);
+                setLoading(true);
-        const data = await getAlertEvents();
+                const data = await getAlertEvents();
-        setAlertEvents(data);
+                setAlertEvents(data);
-      } catch (err) {
+            } catch (err) {
-        setError(err.message);
+                setError(err.message);
-        console.error("Failed to fetch alert events:", err);
+                console.error("Failed to fetch alert events:", err);
-      } finally {
+            } finally {
-        setLoading(false);
+                setLoading(false);
-      }
+            }
+        }
+
+        fetchAlertEvents();
+    }, []);
+
+    if (loading) {
+        return <div style={{ padding: "2rem" }}>Loading...</div>;
     }
 
-    fetchAlertEvents();
+    if (error) {
-  }, []);
+        return (
+            <div style={{ padding: "2rem", color: "red" }}>Error: {error}</div>
+        );
+    }
 
-  if (loading) {
+    return (
-    return <div style={{ padding: "2rem" }}>Loading...</div>;
+        <div style={{ maxWidth: "800px", margin: "0 auto", padding: "2rem" }}>
-  }
+            <h1>Recent Alerts</h1>
 
-  if (error) {
+            {alertEvents.length === 0 ? (
-    return <div style={{ padding: "2rem", color: "red" }}>Error: {error}</div>;
+                <p style={{ color: "#666" }}>No alerts yet</p>
-  }
+            ) : (
-
+                <ul style={{ listStyle: "none", padding: 0 }}>
-  return (
+                    {alertEvents.map((event) => (
-    <div style={{ maxWidth: "800px", margin: "0 auto", padding: "2rem" }}>
+                        <li
-      <h1>Recent Alerts</h1>
+                            key={event.id}
-
+                            style={{
-      {alertEvents.length === 0 ? (
+                                padding: "1rem",
-        <p style={{ color: "#666" }}>No alerts yet</p>
+                                marginBottom: "0.75rem",
-      ) : (
+                                border: "1px solid #ddd",
-        <ul style={{ listStyle: "none", padding: 0 }}>
+                                borderRadius: "4px",
-          {alertEvents.map((event) => (
+                            }}
-            <li
+                        >
-              key={event.id}
+                            <div style={{ marginBottom: "0.5rem" }}>
-              style={{
+                                {event.message}
-                padding: "1rem",
+                            </div>
-                marginBottom: "0.75rem",
+                            {event.address_label && (
-                border: "1px solid #ddd",
+                                <div
-                borderRadius: "4px",
+                                    style={{
-              }}
+                                        fontSize: "0.9rem",
-            >
+                                        color: "#666",
-              <div style={{ marginBottom: "0.5rem" }}>{event.message}</div>
+                                        marginBottom: "0.25rem",
-              {event.address_label && (
+                                    }}
-                <div style={{ fontSize: "0.9rem", color: "#666", marginBottom: "0.25rem" }}>
+                                >
-                  Address: {event.address_label}
+                                    Address: {event.address_label}
-                </div>
+                                </div>
-              )}
+                            )}
-              <small style={{ color: "#999" }}>
+                            <small style={{ color: "#999" }}>
-                {formatTimestamp(event.timestamp)}
+                                {formatTimestamp(event.timestamp)}
-              </small>
+                            </small>
-            </li>
+                        </li>
-          ))}
+                    ))}
-        </ul>
+                </ul>
-      )}
+            )}
-    </div>
+        </div>
-  );
+    );
 }
 
 // Helper to format timestamp for display
 function formatTimestamp(timestamp) {
-  const date = new Date(timestamp);
+    const date = new Date(timestamp);
-  return date.toLocaleString();
+    return date.toLocaleString();
 }

frontend/src/pages/Login.jsx

@@ -1,143 +1,146 @@
 /**
  * Login Page
- * 
+ *
  * Allows existing users to sign in with email and password
  */
 
-import { useState } from 'react';
+import { useState } from "react";
-import { Link, useNavigate } from 'react-router-dom';
+import { Link, useNavigate } from "react-router-dom";
-import { useAuth } from '../contexts/AuthContext';
+import { useAuth } from "../contexts/AuthContext";
 
 export default function Login() {
-  const [email, setEmail] = useState('');
+    const [email, setEmail] = useState("");
-  const [password, setPassword] = useState('');
+    const [password, setPassword] = useState("");
-  const [error, setError] = useState('');
+    const [error, setError] = useState("");
-  const [loading, setLoading] = useState(false);
+    const [loading, setLoading] = useState(false);
-  
-  const { login } = useAuth();
-  const navigate = useNavigate();
 
-  async function handleSubmit(e) {
+    const { login } = useAuth();
-    e.preventDefault();
+    const navigate = useNavigate();
 
-    // Validation
+    async function handleSubmit(e) {
-    if (!email || !password) {
+        e.preventDefault();
-      setError('Please fill in all fields');
+
-      return;
+        // Validation
+        if (!email || !password) {
+            setError("Please fill in all fields");
+            return;
+        }
+
+        try {
+            setError("");
+            setLoading(true);
+            await login(email, password);
+            navigate("/addresses"); // Redirect to main app
+        } catch (err) {
+            setError("Failed to log in: " + err.message);
+        } finally {
+            setLoading(false);
+        }
     }
 
-    try {
+    return (
-      setError('');
+        <div
-      setLoading(true);
-      await login(email, password);
-      navigate('/addresses'); // Redirect to main app
-    } catch (err) {
-      setError('Failed to log in: ' + err.message);
-    } finally {
-      setLoading(false);
-    }
-  }
-
-  return (
-    <div style={{ 
-      maxWidth: '400px', 
-      margin: '4rem auto', 
-      padding: '2rem',
-      border: '1px solid #333',
-      borderRadius: '8px'
-    }}>
-      <h1 style={{ marginBottom: '2rem', textAlign: 'center' }}>
-        Koin Ping - Login
-      </h1>
-
-      {error && (
-        <div style={{ 
-          padding: '0.75rem', 
-          marginBottom: '1rem', 
-          backgroundColor: '#ff000020',
-          border: '1px solid #ff0000',
-          borderRadius: '4px',
-          color: '#ff6666'
-        }}>
-          {error}
-        </div>
-      )}
-
-      <form onSubmit={handleSubmit}>
-        <div style={{ marginBottom: '1rem' }}>
-          <label style={{ display: 'block', marginBottom: '0.5rem' }}>
-            Email
-          </label>
-          <input
-            type="email"
-            value={email}
-            onChange={(e) => setEmail(e.target.value)}
-            disabled={loading}
             style={{
-              width: '100%',
+                maxWidth: "400px",
-              padding: '0.5rem',
+                margin: "4rem auto",
-              fontSize: '1rem',
+                padding: "2rem",
-              backgroundColor: '#1a1a1a',
+                border: "1px solid #333",
-              border: '1px solid #444',
+                borderRadius: "8px",
-              borderRadius: '4px',
-              color: 'white'
             }}
-            required
-          />
-        </div>
-
-        <div style={{ marginBottom: '1.5rem' }}>
-          <label style={{ display: 'block', marginBottom: '0.5rem' }}>
-            Password
-          </label>
-          <input
-            type="password"
-            value={password}
-            onChange={(e) => setPassword(e.target.value)}
-            disabled={loading}
-            style={{
-              width: '100%',
-              padding: '0.5rem',
-              fontSize: '1rem',
-              backgroundColor: '#1a1a1a',
-              border: '1px solid #444',
-              borderRadius: '4px',
-              color: 'white'
-            }}
-            required
-          />
-        </div>
-
-        <button
-          type="submit"
-          disabled={loading}
-          style={{
-            width: '100%',
-            padding: '0.75rem',
-            fontSize: '1rem',
-            backgroundColor: loading ? '#333' : '#0066cc',
-            color: 'white',
-            border: 'none',
-            borderRadius: '4px',
-            cursor: loading ? 'not-allowed' : 'pointer'
-          }}
         >
-          {loading ? 'Logging in...' : 'Log In'}
+            <h1 style={{ marginBottom: "2rem", textAlign: "center" }}>
-        </button>
+                Koin Ping - Login
-      </form>
+            </h1>
 
-      <div style={{ marginTop: '1.5rem', textAlign: 'center' }}>
+            {error && (
-        <p style={{ color: '#999' }}>
+                <div
-          Don't have an account?{' '}
+                    style={{
-          <Link 
+                        padding: "0.75rem",
-            to="/signup" 
+                        marginBottom: "1rem",
-            style={{ color: '#0066cc', textDecoration: 'none' }}
+                        backgroundColor: "#ff000020",
-          >
+                        border: "1px solid #ff0000",
-            Sign up here
+                        borderRadius: "4px",
-          </Link>
+                        color: "#ff6666",
-        </p>
+                    }}
-      </div>
+                >
-    </div>
+                    {error}
-  );
+                </div>
+            )}
+
+            <form onSubmit={handleSubmit}>
+                <div style={{ marginBottom: "1rem" }}>
+                    <label style={{ display: "block", marginBottom: "0.5rem" }}>
+                        Email
+                    </label>
+                    <input
+                        type="email"
+                        value={email}
+                        onChange={(e) => setEmail(e.target.value)}
+                        disabled={loading}
+                        style={{
+                            width: "100%",
+                            padding: "0.5rem",
+                            fontSize: "1rem",
+                            backgroundColor: "#1a1a1a",
+                            border: "1px solid #444",
+                            borderRadius: "4px",
+                            color: "white",
+                        }}
+                        required
+                    />
+                </div>
+
+                <div style={{ marginBottom: "1.5rem" }}>
+                    <label style={{ display: "block", marginBottom: "0.5rem" }}>
+                        Password
+                    </label>
+                    <input
+                        type="password"
+                        value={password}
+                        onChange={(e) => setPassword(e.target.value)}
+                        disabled={loading}
+                        style={{
+                            width: "100%",
+                            padding: "0.5rem",
+                            fontSize: "1rem",
+                            backgroundColor: "#1a1a1a",
+                            border: "1px solid #444",
+                            borderRadius: "4px",
+                            color: "white",
+                        }}
+                        required
+                    />
+                </div>
+
+                <button
+                    type="submit"
+                    disabled={loading}
+                    style={{
+                        width: "100%",
+                        padding: "0.75rem",
+                        fontSize: "1rem",
+                        backgroundColor: loading ? "#333" : "#0066cc",
+                        color: "white",
+                        border: "none",
+                        borderRadius: "4px",
+                        cursor: loading ? "not-allowed" : "pointer",
+                    }}
+                >
+                    {loading ? "Logging in..." : "Log In"}
+                </button>
+            </form>
+
+            <div style={{ marginTop: "1.5rem", textAlign: "center" }}>
+                <p style={{ color: "#999" }}>
+                    Don't have an account?{" "}
+                    <Link
+                        to="/signup"
+                        style={{ color: "#0066cc", textDecoration: "none" }}
+                    >
+                        Sign up here
+                    </Link>
+                </p>
+            </div>
+        </div>
+    );
 }
-

frontend/src/pages/Signup.jsx

@@ -1,185 +1,188 @@
 /**
  * Signup Page
- * 
+ *
  * Allows new users to create an account with email and password
  */
 
-import { useState } from 'react';
+import { useState } from "react";
-import { Link, useNavigate } from 'react-router-dom';
+import { Link, useNavigate } from "react-router-dom";
-import { useAuth } from '../contexts/AuthContext';
+import { useAuth } from "../contexts/AuthContext";
 
 export default function Signup() {
-  const [email, setEmail] = useState('');
+    const [email, setEmail] = useState("");
-  const [password, setPassword] = useState('');
+    const [password, setPassword] = useState("");
-  const [confirmPassword, setConfirmPassword] = useState('');
+    const [confirmPassword, setConfirmPassword] = useState("");
-  const [error, setError] = useState('');
+    const [error, setError] = useState("");
-  const [loading, setLoading] = useState(false);
+    const [loading, setLoading] = useState(false);
-  
-  const { signup } = useAuth();
-  const navigate = useNavigate();
 
-  async function handleSubmit(e) {
+    const { signup } = useAuth();
-    e.preventDefault();
+    const navigate = useNavigate();
 
-    // Validation
+    async function handleSubmit(e) {
-    if (!email || !password || !confirmPassword) {
+        e.preventDefault();
-      setError('Please fill in all fields');
+
-      return;
+        // Validation
+        if (!email || !password || !confirmPassword) {
+            setError("Please fill in all fields");
+            return;
+        }
+
+        if (password !== confirmPassword) {
+            setError("Passwords do not match");
+            return;
+        }
+
+        if (password.length < 6) {
+            setError("Password must be at least 6 characters");
+            return;
+        }
+
+        try {
+            setError("");
+            setLoading(true);
+            await signup(email, password);
+            navigate("/addresses"); // Auto-login and redirect
+        } catch (err) {
+            // Firebase-specific error messages
+            if (err.code === "auth/email-already-in-use") {
+                setError("Email already in use. Try logging in instead.");
+            } else if (err.code === "auth/invalid-email") {
+                setError("Invalid email address");
+            } else if (err.code === "auth/weak-password") {
+                setError("Password is too weak");
+            } else {
+                setError("Failed to create account: " + err.message);
+            }
+        } finally {
+            setLoading(false);
+        }
     }
 
-    if (password !== confirmPassword) {
+    return (
-      setError('Passwords do not match');
+        <div
-      return;
-    }
-
-    if (password.length < 6) {
-      setError('Password must be at least 6 characters');
-      return;
-    }
-
-    try {
-      setError('');
-      setLoading(true);
-      await signup(email, password);
-      navigate('/addresses'); // Auto-login and redirect
-    } catch (err) {
-      // Firebase-specific error messages
-      if (err.code === 'auth/email-already-in-use') {
-        setError('Email already in use. Try logging in instead.');
-      } else if (err.code === 'auth/invalid-email') {
-        setError('Invalid email address');
-      } else if (err.code === 'auth/weak-password') {
-        setError('Password is too weak');
-      } else {
-        setError('Failed to create account: ' + err.message);
-      }
-    } finally {
-      setLoading(false);
-    }
-  }
-
-  return (
-    <div style={{ 
-      maxWidth: '400px', 
-      margin: '4rem auto', 
-      padding: '2rem',
-      border: '1px solid #333',
-      borderRadius: '8px'
-    }}>
-      <h1 style={{ marginBottom: '2rem', textAlign: 'center' }}>
-        Koin Ping - Sign Up
-      </h1>
-
-      {error && (
-        <div style={{ 
-          padding: '0.75rem', 
-          marginBottom: '1rem', 
-          backgroundColor: '#ff000020',
-          border: '1px solid #ff0000',
-          borderRadius: '4px',
-          color: '#ff6666'
-        }}>
-          {error}
-        </div>
-      )}
-
-      <form onSubmit={handleSubmit}>
-        <div style={{ marginBottom: '1rem' }}>
-          <label style={{ display: 'block', marginBottom: '0.5rem' }}>
-            Email
-          </label>
-          <input
-            type="email"
-            value={email}
-            onChange={(e) => setEmail(e.target.value)}
-            disabled={loading}
             style={{
-              width: '100%',
+                maxWidth: "400px",
-              padding: '0.5rem',
+                margin: "4rem auto",
-              fontSize: '1rem',
+                padding: "2rem",
-              backgroundColor: '#1a1a1a',
+                border: "1px solid #333",
-              border: '1px solid #444',
+                borderRadius: "8px",
-              borderRadius: '4px',
-              color: 'white'
             }}
-            required
-          />
-        </div>
-
-        <div style={{ marginBottom: '1rem' }}>
-          <label style={{ display: 'block', marginBottom: '0.5rem' }}>
-            Password
-          </label>
-          <input
-            type="password"
-            value={password}
-            onChange={(e) => setPassword(e.target.value)}
-            disabled={loading}
-            style={{
-              width: '100%',
-              padding: '0.5rem',
-              fontSize: '1rem',
-              backgroundColor: '#1a1a1a',
-              border: '1px solid #444',
-              borderRadius: '4px',
-              color: 'white'
-            }}
-            required
-          />
-        </div>
-
-        <div style={{ marginBottom: '1.5rem' }}>
-          <label style={{ display: 'block', marginBottom: '0.5rem' }}>
-            Confirm Password
-          </label>
-          <input
-            type="password"
-            value={confirmPassword}
-            onChange={(e) => setConfirmPassword(e.target.value)}
-            disabled={loading}
-            style={{
-              width: '100%',
-              padding: '0.5rem',
-              fontSize: '1rem',
-              backgroundColor: '#1a1a1a',
-              border: '1px solid #444',
-              borderRadius: '4px',
-              color: 'white'
-            }}
-            required
-          />
-        </div>
-
-        <button
-          type="submit"
-          disabled={loading}
-          style={{
-            width: '100%',
-            padding: '0.75rem',
-            fontSize: '1rem',
-            backgroundColor: loading ? '#333' : '#0066cc',
-            color: 'white',
-            border: 'none',
-            borderRadius: '4px',
-            cursor: loading ? 'not-allowed' : 'pointer'
-          }}
         >
-          {loading ? 'Creating account...' : 'Sign Up'}
+            <h1 style={{ marginBottom: "2rem", textAlign: "center" }}>
-        </button>
+                Koin Ping - Sign Up
-      </form>
+            </h1>
 
-      <div style={{ marginTop: '1.5rem', textAlign: 'center' }}>
+            {error && (
-        <p style={{ color: '#999' }}>
+                <div
-          Already have an account?{' '}
+                    style={{
-          <Link 
+                        padding: "0.75rem",
-            to="/login" 
+                        marginBottom: "1rem",
-            style={{ color: '#0066cc', textDecoration: 'none' }}
+                        backgroundColor: "#ff000020",
-          >
+                        border: "1px solid #ff0000",
-            Log in here
+                        borderRadius: "4px",
-          </Link>
+                        color: "#ff6666",
-        </p>
+                    }}
-      </div>
+                >
-    </div>
+                    {error}
-  );
+                </div>
+            )}
+
+            <form onSubmit={handleSubmit}>
+                <div style={{ marginBottom: "1rem" }}>
+                    <label style={{ display: "block", marginBottom: "0.5rem" }}>
+                        Email
+                    </label>
+                    <input
+                        type="email"
+                        value={email}
+                        onChange={(e) => setEmail(e.target.value)}
+                        disabled={loading}
+                        style={{
+                            width: "100%",
+                            padding: "0.5rem",
+                            fontSize: "1rem",
+                            backgroundColor: "#1a1a1a",
+                            border: "1px solid #444",
+                            borderRadius: "4px",
+                            color: "white",
+                        }}
+                        required
+                    />
+                </div>
+
+                <div style={{ marginBottom: "1rem" }}>
+                    <label style={{ display: "block", marginBottom: "0.5rem" }}>
+                        Password
+                    </label>
+                    <input
+                        type="password"
+                        value={password}
+                        onChange={(e) => setPassword(e.target.value)}
+                        disabled={loading}
+                        style={{
+                            width: "100%",
+                            padding: "0.5rem",
+                            fontSize: "1rem",
+                            backgroundColor: "#1a1a1a",
+                            border: "1px solid #444",
+                            borderRadius: "4px",
+                            color: "white",
+                        }}
+                        required
+                    />
+                </div>
+
+                <div style={{ marginBottom: "1.5rem" }}>
+                    <label style={{ display: "block", marginBottom: "0.5rem" }}>
+                        Confirm Password
+                    </label>
+                    <input
+                        type="password"
+                        value={confirmPassword}
+                        onChange={(e) => setConfirmPassword(e.target.value)}
+                        disabled={loading}
+                        style={{
+                            width: "100%",
+                            padding: "0.5rem",
+                            fontSize: "1rem",
+                            backgroundColor: "#1a1a1a",
+                            border: "1px solid #444",
+                            borderRadius: "4px",
+                            color: "white",
+                        }}
+                        required
+                    />
+                </div>
+
+                <button
+                    type="submit"
+                    disabled={loading}
+                    style={{
+                        width: "100%",
+                        padding: "0.75rem",
+                        fontSize: "1rem",
+                        backgroundColor: loading ? "#333" : "#0066cc",
+                        color: "white",
+                        border: "none",
+                        borderRadius: "4px",
+                        cursor: loading ? "not-allowed" : "pointer",
+                    }}
+                >
+                    {loading ? "Creating account..." : "Sign Up"}
+                </button>
+            </form>
+
+            <div style={{ marginTop: "1.5rem", textAlign: "center" }}>
+                <p style={{ color: "#999" }}>
+                    Already have an account?{" "}
+                    <Link
+                        to="/login"
+                        style={{ color: "#0066cc", textDecoration: "none" }}
+                    >
+                        Log in here
+                    </Link>
+                </p>
+            </div>
+        </div>
+    );
 }
-

frontend/tsconfig.json

@@ -1,25 +1,24 @@
 {
-  "compilerOptions": {
+    "compilerOptions": {
-    "target": "ES2020",
+        "target": "ES2020",
-    "useDefineForClassFields": true,
+        "useDefineForClassFields": true,
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+        "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
+        "module": "ESNext",
-    "skipLibCheck": true,
+        "skipLibCheck": true,
 
-    /* Bundler mode */
+        /* Bundler mode */
-    "moduleResolution": "bundler",
+        "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
+        "allowImportingTsExtensions": true,
-    "resolveJsonModule": true,
+        "resolveJsonModule": true,
-    "isolatedModules": true,
+        "isolatedModules": true,
-    "noEmit": true,
+        "noEmit": true,
-    "jsx": "react-jsx",
+        "jsx": "react-jsx",
 
-    /* Linting */
+        /* Linting */
-    "strict": true,
+        "strict": true,
-    "noUnusedLocals": true,
+        "noUnusedLocals": true,
-    "noUnusedParameters": true,
+        "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true
+        "noFallthroughCasesInSwitch": true
-  },
+    },
-  "include": ["src"]
+    "include": ["src"]
 }
-

frontend/vite.config.js

@@ -1,17 +1,16 @@
-import { defineConfig } from 'vite'
+import { defineConfig } from "vite";
-import react from '@vitejs/plugin-react'
+import react from "@vitejs/plugin-react";
 
 // https://vitejs.dev/config/
 export default defineConfig({
-  plugins: [react()],
+    plugins: [react()],
-  server: {
+    server: {
-    port: 3000,
+        port: 3000,
-    proxy: {
+        proxy: {
-      '/v1': {
+            "/v1": {
-        target: 'http://localhost:3001',
+                target: "http://localhost:3001",
-        changeOrigin: true,
+                changeOrigin: true,
-      },
+            },
+        },
     },
-  },
+});
-})
-