Mitch Chain · coin_blockchain

Workspace for Mitch Chain — a Cosmos SDK Layer-1 designed to issue the MTC coin and host on-chain loyalty + AI-credit logic for the Mitch ecosystem (MitchAI, Mitch from Transylvania, partner outlets).

---

What this is

coin_blockchain is an exploration workspace where the design and the first scaffolded implementation of Mitch Chain live together:

• An Ignite CLI–scaffolded Cosmos SDK app (mitch-ignite/) — the working starting point for the chain, built on Cosmos SDK + CometBFT with the standard bank, staking, gov, ibc-transfer, and interchain-accounts modules.
• Design documents (project_overview.txt, readme.txt, CLAUDE.md, AGENTS.md, MEMORY.md) — the engineering brief that turns the generic Ignite scaffold into Mitch Chain: native MTC coin, mitch account prefix, custom x/app module for loyalty rewards and AI credits, IBC posture, optional CosmWasm, and a production deployment plan on AWS.

The work is deliberately staged: spin up a real Cosmos chain locally first, validate the toolchain end-to-end (build, test, proto-gen, localnet, monitoring), then customise the scaffold into the Mitch Chain spec.

This is research-grade WIP, not a mainnet. Treat the design notes as a spec, the scaffold as a substrate, and the customisation as an open roadmap.

---

Why a chain at all

MTC is intended as a single primitive across three Mitch surfaces:

Surface	What MTC is for
Mitch from Transylvania (food market)	Customer loyalty points with on-chain provenance — durable across vendors and seasons.
MitchAI (hospitality AI suite)	AI-credit accounting: each outlet's agent operations debit MTC from a credit pool with auditable balance changes.
Partner outlets	Vendor payments + reward settlement with shared, programmable rules instead of per-vendor spreadsheets.

That set of use cases doesn't need a public general-purpose L1, but it does need: deterministic execution, on-chain audit trail, IBC-friendly settlement, low operating cost, and the option to add CosmWasm contracts later. Cosmos SDK is the smallest viable hammer for that nail.

---

Target spec (Mitch Chain)

From the design notes in this repo:

Property	Value
Name	Mitch Chain
Daemon binary	mitchd
Chain ID	mitch-1
Native coin	MTC
Base denomination	uMTC (1 MTC = 1,000,000 uMTC)
Account prefix	mitch
Consensus	CometBFT (PoS)
SDK	Cosmos SDK v0.52+
Standard modules	bank, staking, gov, slashing, mint, ibc-transfer, interchain-accounts
Custom module	x/app — loyalty rewards + AI credits (planned: x/loyalty, x/aicredits)
Smart contracts	CosmWasm (optional, planned)
Deployment target	AWS (Terraform + systemd validators + sentry nodes)
Monitoring	Prometheus + Grafana (Cosmos dashboard)

---

Repository layout

coin_blockchain/
├── mitch-ignite/                  Ignite-scaffolded Cosmos SDK app (working code)
│   ├── app/                       Cosmos SDK app wiring
│   ├── cmd/                       Binary entrypoint (will become mitchd)
│   ├── proto/                     Protobuf definitions (buf-managed)
│   ├── x/                         Custom modules
│   ├── networks/local/            Docker Compose localnet (planned)
│   ├── deploy/aws/                Terraform + systemd (planned)
│   ├── monitor/                   Prometheus + Grafana (planned)
│   ├── docs/                      Operational runbooks
│   ├── testutil/                  Test helpers
│   ├── config.yml                 Ignite config (default scaffold)
│   ├── Makefile                   build / install / test / proto-gen
│   ├── buf.yaml · buf.lock        Protobuf toolchain config
│   ├── go.mod · go.sum            Go module graph
│   └── readme.md                  Ignite scaffold's stock README
│
├── project_overview.txt           Full engineering brief: chain spec, module plan,
│                                  Docker + AWS topology, monitoring, CosmWasm path
├── readme.txt                     "Why Cosmos SDK + Ignite" rationale and quickstart
├── CLAUDE.md                      Project context for Claude Code (this repo)
├── AGENTS.md                      Repository contribution guidelines
├── MEMORY.md                      Long-running context / decisions log
└── mitch-chain                    (placeholder — full custom app to land here)

---

Status — what's done, what's next

Done

• Cosmos SDK + Ignite CLI workspace stood up (mitch-ignite/).
• Protobuf toolchain wired (buf.yaml, buf.lock).
• Build / test / proto-gen pipeline working via Makefile.
• Localnet bootable with ignite chain serve.
• Design spec captured: token economics, module plan, AWS topology, monitoring stack, IBC posture, CosmWasm path.

In progress / next

• Rename binary to mitchd, denom to uMTC/MTC, account prefix to mitch, chain ID to mitch-1.
• Implement x/loyalty and x/aicredits modules with keepers, message servers, and integration tests (x/app/keeper/ai_credits_test.go named in AGENTS.md).
• Wire localnet Docker Compose under networks/local/.
• Stand up AWS deployment (Terraform: validator + sentry + RPC, systemd unit files, snapshot sync script).
• Prometheus + Grafana monitoring stack with the Cosmos dashboard.
• Optional: CosmWasm enablement + a sample loyalty contract under wasm-demo/.

---

Quickstart (local development)

Prerequisites

• Go 1.24+ — required for Cosmos SDK v0.52+ toolchain features.
• Ignite CLI — curl https://get.ignite.com/cli! | bash (macOS: brew install ignite).
• Docker + Docker Compose — for the planned localnet.
• (Optional) Node 18+ if you scaffold a Vue frontend with Ignite.

Boot the dev chain

cd mitch-ignite
ignite chain serve

serve installs dependencies, builds the node, initialises genesis, and starts a single-validator chain in development mode with hot reload on proto/source changes.

Build & test the node

cd mitch-ignite
make build       # → ./build/appd  (will become ./build/mitchd after rename)
make install     # → installs the binary into $GOBIN
make test        # → vet + vuln check + unit tests
go test ./...    # full test suite

When running in sandboxed environments, set GOCACHE, GOMODCACHE, and GOPATH to writable paths (e.g. GOCACHE=$(pwd)/.gocache).

Regenerate protobuf bindings

cd mitch-ignite
make proto-gen
go mod tidy

---

Architecture (target)

                  ┌────────────────────────────────────────────────────┐
                  │                    Mitch Chain                     │
                  │                    (mitch-1)                       │
                  │                                                    │
                  │   ┌──────────────┐  ┌──────────────┐               │
                  │   │  bank        │  │  staking     │  standard      │
                  │   │  gov         │  │  slashing    │  Cosmos SDK    │
                  │   │  mint        │  │  ibc-xfer    │  modules        │
                  │   └──────────────┘  └──────────────┘               │
                  │                                                    │
                  │   ┌──────────────┐  ┌──────────────┐               │
                  │   │  x/loyalty   │  │  x/aicredits │  Mitch-specific│
                  │   │  rewards     │  │  AI-credit   │  modules       │
                  │   │  accrual     │  │  accounting  │                │
                  │   └──────────────┘  └──────────────┘               │
                  │                                                    │
                  │   ┌──────────────┐  ┌──────────────┐               │
                  │   │  CosmWasm    │  │  Interchain  │  optional /    │
                  │   │  (planned)   │  │  accounts    │  forward-looking│
                  │   └──────────────┘  └──────────────┘               │
                  └────────────────────────────────────────────────────┘
                                          │
                                          ▼
                  ┌────────────────────────────────────────────────────┐
                  │      AWS production topology (planned)              │
                  │                                                    │
                  │   Validator node     Sentry node(s)    RPC/API     │
                  │   (systemd unit)     (systemd units)   (Cloud LB)  │
                  │        │                  │                 │      │
                  │        └──────────────────┴─────────────────┘      │
                  │                          │                         │
                  │                          ▼                         │
                  │              Prometheus + Grafana                  │
                  │              (Cosmos node dashboard)               │
                  └────────────────────────────────────────────────────┘

---

Design decisions

• Cosmos SDK over Substrate / EVM L2. Cosmos gives a clean module system, mature tooling (Ignite, buf), and IBC out of the box — the smallest viable substrate for an application-specific chain whose primary use case is settlement, not general computation. Substrate is more powerful but takes longer to operationalise; an EVM L2 would bring useful liquidity but ties us to Ethereum's mempool dynamics and gas surface, neither of which MTC needs.
• Application-specific chain, not a token on a shared L1. Mitch Chain is not a speculative asset. It is the settlement layer for loyalty, AI-credit accounting, and vendor payments across the Mitch ecosystem. Owning the chain gives us deterministic costs, programmable monetary policy, and a clean audit trail without paying for someone else's congestion.
• IBC-ready from day one. Even though Mitch Chain starts as a sovereign zone with no IBC partners, leaving the modules in place costs nothing today and means future cross-zone settlement is a config flag, not a re-architecture.
• CosmWasm is optional and deferred. The native module path (x/loyalty, x/aicredits) is fast to ship and easier to audit. CosmWasm is the right answer if partner businesses want to push their own rules into the chain — but until that demand exists, native modules win on simplicity.
• AWS over self-hosted hardware (for now). Terraform + systemd on EC2 gives reproducible validator + sentry topology without burning months on hardware procurement. The cost of running a small validator set on EC2 is in the noise relative to the cost of getting the implementation right.

---

How this fits the broader portfolio

coin_blockchain sits inside a wider Mitch ecosystem:

• MitchAI — vertical operational AI suite for hospitality. MTC is the credit unit used to meter AI operations (HACCP records, social posts, menu changes, supplier reconciliation) per outlet.
• Mitch_coin — earlier Solidity / Hardhat / React experiment that established the token economics intuition before committing to a sovereign chain.
• Mitch from Transylvania — the operating food-market business that anchors the loyalty use case in reality.

Full portfolio + case studies: https://bogdan0708.github.io

---

Contributing

Contribution guidelines and Cosmos SDK style notes live in AGENTS.md. The short version:

• Keep keepers in x/<module>/keeper, types in x/<module>/types, message servers in msg_server.go.
• Run gofmt on edited Go files before submitting.
• Tests are Test<Scenario> with t.Run for table-driven cases.
• Integration coverage for loyalty + credits lives in x/app/keeper/integration_test.go; extend it when adding new state transitions.
• Sensitive configuration (validator keys, RPC endpoints) belongs in config.yml or environment variables, never in source.

---

Author

Vasile Bogdan Godja — Applied AI Engineer · founder, sole engineer.

📍 London, UK · 📧 godjabogdan@gmail.com · Portfolio · LinkedIn · GitHub

Mitch Chain is one piece of a broader stack of production AI and operational systems shipped end-to-end. See bogdan0708.github.io for case studies of EuFund (multi-agent EU funding platform), PrimarIA (Romanian municipal AI), and MitchAI (vertical hospitality AI).

---

_{Mitch Chain · MTC · © 2026 Vasile Bogdan Godja · experimental / WIP}