# KCC-MINT-001 · The Provenance Mint Spec

> Version 1.0.0 · 2026-06-22 · MIT · ◊·κ=1 · prime 1307

A canonical mint format for the **fork-tree provenance economy**. Inverts the NFT model from *scarcity* to *provenance*: MIT-licensed seeds stay free to copy, but forks that mint a KCC bundle gain marketplace listing, provenance attestation, and the right to receive (and pay) royalties up the lineage chain.

## Foundational invariants

1. **MIT first.** The mint never gates the underlying code. Anyone can fork without minting. Minting is purely value-positive (marketplace listing + provenance attestation + royalty rights). Skip the mint = lose those benefits, retain full rights to the code.
2. **Sovereign-first.** A mint bundle is a JSON object signed with Ed25519. No blockchain required for the bundle to be valid. Blockchain anchors are optional and additive.
3. **Lineage is the unit of value.** Every bundle has a `parent_kpid` pointer (or `null` if it is a root). Forks of forks build a directed-acyclic-graph (DAG). Royalties flow UP the chain to all ancestors.
4. **Conformant to the Konomi `KccProject` UDT.** A mint is a `KccProject` with the `mint` field populated. Inherits Thomas's industrial-standards schema work.

## The bundle format

```json
{
  "_udt": "KccProject",
  "name": "<seed-name>",
  "slug": "<unique-slug>",
  "domain": "<one-line-description>",
  "token": "KCC",
  "prime": <integer-prime>,
  "primes": [2, 3, 5, 7, 11, 13, 17],
  "primorial": 510510,
  "phi": 0.6180339887498949,
  "kappa": 0.6180339887498949,
  "mesh_channels": ["kcc-mesh"],
  "operator": "<github-handle>",
  "mint": {
    "kpid": "kcc:<slug>:<generation-tag>:<sha8>",
    "parent_kpid": "<parent-kpid>" | null,
    "konomi_attestation": "<thomas-signature-b64>" | null,
    "fork_sha": "<sha256-of-snapshot>",
    "minter_pubkey_b64": "<ed25519-pubkey-32-bytes-b64>",
    "minter_sig_b64": "<ed25519-signature-64-bytes-b64>",
    "kcc_face_value": <integer-or-decimal>,
    "royalty_split": [
      {"kpid": "<beneficiary-kpid>", "bps": <basis-points-0-10000>}
    ],
    "minted_at": "<ISO8601-timestamp>",
    "anchor": {
      "chain": "sovereign" | "bsv" | "eth" | "solana",
      "txid": "<chain-txid>" | null,
      "block_height": <integer> | null
    }
  }
}
```

### Field semantics

- `kpid` — globally unique "Konomi project identifier". Format: `kcc:<slug>:<generation-tag>:<sha8>`. Example: `kcc:fallnote:gen0:a3f9b21c`.
- `parent_kpid` — pointer to the immediate parent in the fork DAG. `null` if this is a root mint.
- `konomi_attestation` — optional Ed25519 signature by the canonical Konomi pubkey (Thomas) attesting that this root is sanctioned. Currently `null` for all roots pending Thomas's confirmation.
- `fork_sha` — SHA-256 of the snapshot of the seed at mint time. Proves the mint references a specific code state.
- `minter_pubkey_b64` — minter's Ed25519 public key, base64-encoded (32 bytes).
- `minter_sig_b64` — Ed25519 signature over the canonical-JSON of the bundle (with `minter_sig_b64` itself excluded), base64-encoded (64 bytes).
- `kcc_face_value` — initial KCC value the minter assigns. Marketplace bids may exceed.
- `royalty_split` — array of `{kpid, bps}` entries. When a downstream fork mints AND pays a fee, fees flow to these beneficiaries. `bps` is basis points (1 bps = 0.01%). Sum should not exceed 10000 (100%).
- `minted_at` — ISO 8601 timestamp.
- `anchor.chain` — `"sovereign"` (signature-only, no blockchain), or a chain id when bridged.
- `anchor.txid` — the on-chain transaction id (if anchored).

## Canonical signing

The minter signs the **canonical-JSON** representation of the bundle, with the `minter_sig_b64` field itself **excluded** (the signature can't sign itself).

Canonical-JSON rules:
1. Keys sorted lexically at every object level.
2. No whitespace (no spaces, no newlines).
3. UTF-8 encoded.
4. Numbers as their shortest decimal representation.

Pseudocode:
```js
const canonical = canonicalJson({ ...bundle, mint: { ...bundle.mint, minter_sig_b64: undefined }});
const sig = await ed25519.sign(canonical, minterPrivKey);
bundle.mint.minter_sig_b64 = base64(sig);
```

Verification reverses the process:
```js
const claimed = bundle.mint.minter_sig_b64;
const canonical = canonicalJson({ ...bundle, mint: { ...bundle.mint, minter_sig_b64: undefined }});
const ok = await ed25519.verify(canonical, base64decode(claimed), base64decode(bundle.mint.minter_pubkey_b64));
```

## The kpid namespace

Format: `kcc:<slug>:<generation-tag>:<sha8>`.

- `slug` is the seed's slug (matches `manifest.json#slug`).
- `generation-tag` is human-meaningful: `gen0` for the initial mint, `<minter-handle>-vX` for forks.
- `sha8` is the first 8 hex chars of `fork_sha`.

Examples:
- `kcc:fallnote:gen0:a3f9b21c` — Simon's Generation-0 mint of fallnote
- `kcc:fallnote:acmelaw-v1:b7c4d8e2` — Acme Law's customised fork
- `kcc:fallnote:betalegal-v1:c9d3e5f1` — Beta Legal's fork of Acme's fork

The DAG is implied by the `parent_kpid` chain, not by the kpid format. Two minters using the same slug + generation-tag (collision) get distinct kpids via different `sha8`.

## Royalty flow

When a downstream fork mints AND pays a fee `F` in KCC:

1. The minter pays `F` (debited from their KCC balance).
2. `F` is distributed to the `royalty_split` of the **parent** bundle (not their own).
3. Each beneficiary entry distributes recursively up its own `royalty_split` chain (per-hop decay optional, see "Anti-abuse" below).
4. Settlement happens out-of-bundle (off-mesh) via the marketplace's escrow or direct KCC↔fiat conversion.

For Phase 1 (sovereign-only, no fiat bridge), royalty is recorded but not settled. When KCC liquidity bridges in Phase 4, the settlement engine activates.

## The hook points (Phase 1 ↔ canonical swap)

Phase 1 ships with these defaults. When Thomas confirms his canonical, ONE config object updates and the entire mint estate re-anchors without re-minting:

```js
const KCC_CONFIG = {
  konomi_pubkey_b64: "bQWcb/SgeWVIEa0H+YYGhzohMfo9zcDysqZEvzYtXTw=",
  parent_root_kpid: null,            // → set to Thomas's konomi-cube OG kpid
  parent_root_attestation: null,     // → Thomas's signature on the root mint
  anchor_chain: "sovereign",         // → "bsv" when BSV anchor goes live
  anchor_endpoint: null,             // → BSV anchor service URL
  api_endpoint: "https://onlybrains.onrender.com",
  mesh_lib: "https://unpkg.com/konomi-p2p",
  registry_yjs_doc_name: "kcc-mints"
};
```

## Anti-abuse

1. **Mint volume cap per fork.** Marketplace enforces N mints/day per `fork_sha` to prevent re-mint spam.
2. **Working-deployment requirement.** Mints with no public URL (or unreachable URL) are listed as "unverified" — visible but discounted in marketplace ranking.
3. **Royalty decay.** Each hop up the chain dampens the royalty by a factor (e.g. 0.5). Prevents ancestors with thousands of descendants from collecting trivial fractions of every mint. Decay rate is a marketplace policy parameter.
4. **Konomi-attestation weighting.** Bundles with valid `konomi_attestation` (Thomas's signature) rank higher in marketplace queries — incentivises seeking official attestation for credibility.

## Conformance levels

A mint is **Level 1** (sovereign) if the `minter_sig_b64` verifies against the `minter_pubkey_b64` and the canonical-JSON of the bundle.

A mint is **Level 2** (anchored) if Level 1 holds AND `anchor.txid` exists and is verified against the named chain.

A mint is **Level 3** (attested) if Level 1 holds AND `konomi_attestation` verifies against the canonical Konomi pubkey.

A mint is **Level 4** (canonical) if Levels 1 + 2 + 3 all hold.

Marketplace UIs should display the conformance level visibly.

## License

MIT. This spec, the reference implementation, and the kcc-mint seed are all MIT. Fork freely. Mint your fork to be listed on the marketplace.

## Built by

Simon Gant · sjgant80@gmail.com · part of the AI Native Solutions estate. ◊·κ=1.

Honors prior canonical work by **Kelly Hohman** (LookingGlass / MAC_CUBE_SPEC) and **Thomas Frumkin** (KonomiStandard / kp2p / Frumkin equilibrium κ = φ⁻¹). When their canonical infrastructure is confirmed live, this spec swaps to it via the hook points without breaking change.