Suito

Suito is a demo stablecoin issuance platform for Japanese financial institutions. It shows how a bank can keep its existing account and transfer systems while adding a Sui-native JPYC issuance and redemption layer.

The project deliberately focuses on the part a bank cannot replace with an ordinary back-office dashboard:

1. Reading fiat deposit events from a bank API.
2. Converting eligible deposits into stablecoin mint requests.
3. Minting JPYC on Sui.
4. Burning JPYC on Sui before instructing a fiat payout.
5. Presenting the workflow through an LLM-first operator console and a thin CLI.

Repository Layout

suito/
  app/         LLM-first issuance console, CLI, SQLite-backed platform layer
  mock-bank/   Local Japanese corporate banking API simulator
  move/        Sui Move package for regulated JPYC, treasury, requests, proofs
  docs/        Architecture, runbooks, research, and product scope

What The Demo Proves

Suito treats the bank as the source of truth for fiat movement and Sui as the source of truth for token supply.

Minting:

customer deposit -> bank API -> SQLite request -> operator approval -> Sui mint

Burning:

JPYC coin object -> Sui burn -> burn digest -> bank transfer request -> payout

The demo uses a single omnibus reserve account in the mock bank. A real issuer would likely split this into collection, reserve or trust, operating, fee, and payout accounts. The important invariant stays the same: outstanding stablecoin supply is an issuer liability backed by fiat reserves.

Current Testnet Deployment

The app defaults to the published testnet package below:

Network:        testnet
Package:        0xfd30189d979039b2564ed0a4459d45c2cd0885215e8327a56a2f39f470154f00
Coin type:      0xfd30189d979039b2564ed0a4459d45c2cd0885215e8327a56a2f39f470154f00::jpyc::JPYC
TreasuryState:  0x9eaa16120b96863ade40166ba1619fd7666edb879a2fdfad0776518dda9ad375
Issuer address: 0x06987a4cd5d7757fb020e34c3e09a295862601acf2acd0b7e3592b40575cba64

The deployment uses the Sui Coin Registry currency path and a regulated JPYC coin type. Published.toml records the published package metadata; local deployment JSON files are ignored because they are machine-specific runtime state.

Quick Start

Prerequisites:

• Bun
• Sui CLI configured for testnet
• A funded Sui testnet address that owns the published package capabilities
• macOS or Linux shell environment

Start the mock bank:

cd mock-bank
bun install
PORT=4010 bun run dev

Start the app in another terminal:

cd app
bun install
bun run dev -- --port 3002

Open:

http://localhost:3002

Check live platform state from the CLI:

cd app
bun run suito status
bun run suito deposits

Core CLI Commands

cd app

# Read bank, SQLite, and Sui state.
bun run suito status

# Pull the latest mock-bank snapshot into SQLite.
bun run suito sync-bank

# Show deposit-backed mint requests.
bun run suito deposits

# Approve a request that passed policy.
bun run suito approve MR-00000587

# Mint JPYC on Sui for an approved request.
bun run suito mint MR-00000587

# Burn JPYC on Sui, then request fiat payout through the bank API.
bun run suito burn --amount 1

# Run the complete local/testnet demo with receipts.
bun run demo:e2e -- --confirm

# Verify MCP tools for agent integrations.
bun run mcp:smoke

The CLI calls the same platform functions as the app. It is intentionally thin: the long-term product boundary is an SDK that can drive both operator UIs and automation.

demo:e2e is the one-command scripted walkthrough for demos. It creates a matched mock-bank deposit, syncs it into SQLite, approves and mints JPYC on Sui, burns JPYC on Sui, requests a bank payout, settles the mock payout, and prints the transaction receipts.

Documentation

• Architecture
• Demo Runbook
• Data Model and API
• SDK Boundary
• Japanese Banking Model
• Minimal Demo Scope
• Stablecoin Issuance Research

Package-specific docs:

• App
• Mock Bank
• Move Package

Verification

The current repo has been verified with:

cd app
bun run typecheck
bun run build

The burn PTB has also been dry-run against testnet for both exact coin burns and split-then-burn cases. A live 1 JPYC redemption was executed on testnet during development to verify the onchain burn plus mock-bank payout path.

Scope Boundaries

Implemented:

• Mock Japanese corporate banking API with virtual accounts, deposits, transfers, idempotency, rail windows, and admin scenario controls.
• Sui Move package for regulated JPYC, treasury state, mint requests, burn requests, reserve attestations, and compliance cases.
• gRPC-based Sui reads through @mysten/sui/grpc.
• Onchain mint and burn execution through Sui CLI scripts.
• MCP tools for status, bank sync, mint approval, onchain mint, and burn/payout.
• SQLite persistence for offchain bank and request state.
• LLM-first React console backed by json-render.
• CLI surface for sync, approval, mint, burn, and status.

Not implemented:

• Real bank integration.
• Production custody or key management.
• Full compliance screening.
• Nautilus enclave proof service.
• Walrus document storage.
• Seal access policies.
• SuiNS transfer execution.
• Multi-approver workflow.

Those are intentionally left as follow-up work so the demo stays centered on the irreducible issuance and redemption path.