CHLOM™ Substrate Master Technical Document

Version 1.0 — Issued by CrownThrive, LLC “Protocols, Modules, and the Roadmap for Building the Decentralized Licensing & Compliance Layer.”

Audience: Runtime engineers, protocol researchers, validator operators, integrators, and Help Center editors curating the CHLOM Substrate category. Scope: Canonical reference for what CHLOM is, how it’s built, how it works in production, and which 30+ follow‑on docs to read next.

0 · How to Use this Master Doc (Help Center Index)

Start here for the big picture and concrete build paths.
Each section ends with “What to read next” cross‑links into the Substrate category.
Code examples are illustrative; the authoritative source is the runtime repository.

1 · System Overview

CHLOM™ (Compliance Hybrid Licensing & Ownership Model) is a Substrate‑based runtime that tokenizes licenses, automates royalties, and enforces compliance via on‑chain rules, validators, and oracles. Licenses are represented as chain‑native NFTs; KPIs and royalties are enforced by deterministic pallets; governance is DAO‑driven.

1.1 High‑Level Architecture

+-----------------------+        +------------------+        +-----------------------+
|  Clients / SDKs       |<------>|  JSON-RPC / WS   |<------>|  CHLOM Node (Runtime) |
|  (TS/JS, Rust)        |        |  (Polkadot-JS)   |        |  FRAME Pallets        |
+-----------------------+        +------------------+        +-----------------------+
                                                             |  pallet_chlom_licensing|
                                                             |  pallet_chlom_kpi      |
+-----------------------+        +------------------+        |  pallet_chlom_royalty  |
| Oracles & Off-chain   |<------>| Off-chain Workers|        |  pallet_chlom_lex      |
| (KYC, IoT, payments)  |        |  + Oracle Pallet |        |  pallet_chlom_dla      |
+-----------------------+        +------------------+        |  pallet_chlom_gov      |
                                                             |  pallet_assets / nfts  |
+-----------------------+        +------------------+        |  pallet_treasury       |
| Indexers & Analytics  |<------>| SubQuery/Sidecar |        |  staking, session, ... |
| (Subsquid/SubQuery)   |        +------------------+        +-----------------------+

1.2 Consensus & Accounts

Consensus: BABE (block production) + GRANDPA (finality).
Staking: NPoS via
Accounts: SS58 addressing; sr25519/ed25519 keys; multisig via

What to read next: Doc 01 — Substrate Runtime Setup Guide; Doc 02 — Network & Keys Handbook.

2 · Core Protocols (Functional Specs)

2.1 Licensing Protocol (LP) Tokenizes rights/obligations as License NFTs (using pallet_nfts or pallet_uniques). Each license carries: jurisdiction, scope, royalty formula, KPI thresholds, escrow rules, transfer constraints.

Extrinsics (examples):

licensing.mint(class_id, metadata, terms_hash)
licensing.revoke(item_id, cause)
licensing.sublicense(item_id, percent, buyer, constraints)
licensing.amend(item_id, terms_hash)

Storage: double maps keyed by

2.2 Compliance Protocol (CP) Deterministic KPI checks + risk scoring. Integrates off‑chain oracles and on‑chain attestations.

kpi.set_thresholds(class_id, metrics[])
kpi.report(item_id, metric_id, value, oracle_sig)
kpi.flag(item_id, code)

2.3 Governance Protocol (GP) DAO built from pallet_collective, pallet_democracy, pallet_scheduler with CHM‑weighted voting and reputation boosts.

gov.propose(call, stake)
gov.set_weighting(model)

2.4 Economic Protocol (EP) Royalty accounting, validator rewards, fee burns.

royalty.route(tx_id, splits[])
treasury.buyback(amount)

What to read next: Doc 03 — Licensing Protocol Spec; Doc 04 — Compliance Protocol Spec; Doc 05 — Governance Protocol Spec; Doc 06 — Economic Protocol Spec.

3 · Runtime Pallets (FRAME)

Pallet	Purpose	Key Storage	Key Extrinsics	Events/Errors
`pallet_chlom_licensing`	Mint/revoke/amend licenses	Licenses, TermsCID, Constraints	`mint`, `revoke`, `amend`, `sublicense`	`LicenseMinted`, `Revoked`
`pallet_chlom_kpi`	KPI thresholds & reports	Thresholds, Reports	`set_thresholds`, `report`	`KpiBreached`
`pallet_chlom_royalty`	Royalty graph & payouts	Splits, Routes, Accruals	`route`, `settle`	`RoyaltySettled`
`pallet_chlom_lex`	License Exchange (LEX)	Orders, Escrows	`list`, `buy`, `partialSell`, `cancel`	`TradeSettled`
`pallet_chlom_dla`	Decentralized Licensing Authority	Cases, Sanctions	`openCase`, `applySanction`, `resolve`	`SanctionApplied`
`pallet_chlom_gov`	CHM‑weighted governance hooks	Weights, Scores	`setWeight`, `addReputation`	`GovWeightChanged`
`pallet_oracle_gateway`	Oracle attestation	Feeds, Sigs	`registerFeed`, `attest`	`Attested`
`pallet_attestations`	Evidence registry	Proofs	`submitProof`	`ProofRecorded`
`pallet_reputation`	Operator scores	Scores	`updateScore`	`ReputationUpdated`
`pallet_sustainability`	Eco/offset ledger	Impact, Pledges	`recordImpact`, `routeOffset`	`ImpactRecorded`

What to read next: Doc 07 — Pallet Design Deep Dives (per pallet).

4 · Data Model & Schemas

License NFT:
Royalty Model: directed acyclic graph of splits with weights, currency, rounding rules.
KPI Profile:
DLA Case:

What to read next: Doc 08 — Runtime Storage & Schemas.

5 · Protocol Flows (Sequence Specs)

5.1 License Lifecycle

Apply → KYC/KYB via oracle; 2) Mint License NFT; 3) Operate and emit KPI/royalty events; 4) Comply (auto checks); 5) Amend/Transfer via LEX; 6) Expire/Revoke.

5.2 Royalty Settlement

Transaction →

5.3 LEX Trade

list()

What to read next: Doc 09 — Sequence Diagrams & State Machines.

6 · Governance & DAO Mechanics

Voting: CHM stake + reputation weight; quorum/threshold curves; conviction locking.
Scheduling: On‑chain
Emergency: Council fast‑track with post‑hoc referendum.

What to read next: Doc 10 — Governance Parameters & Processes.

7 · Token Model (Runtime View)

CHM (governance): fixed supply; staking, voting, validator rewards.
CHLOM (utility): operational fees, license staking; minted/burned per activity via

What to read next: Doc 11 — Token Implementation & Fee Model.

8 · Oracles & Off‑Chain Workers

Signed feeds for KYC/KYB, occupancy (IoT), campaign proofs, and sustainability receipts (EcoDrive/Stripe Climate).
Off‑chain workers batch KPI reports, perform rate‑limited API calls, and submit proofs.

What to read next: Doc 12 — Oracle Gateway & OCW Patterns.

9 · Indexing & Analytics

Indexers: SubQuery/Subsquid projects for KPIs, royalties, LEX trades, DLA cases.
Data Access: GraphQL for dashboards; Sidecar/
Observability: Prometheus metrics; OpenTelemetry traces from node.

What to read next: Doc 13 — Indexing Blueprints; Doc 14 — Observability & Telemetry.

10 · Security, Privacy, and Compliance

Threat model: reentrancy, oracle spoofing, MEV on LEX, censorship.
Controls: audits, fuzzing, property‑based tests, runtime benchmarking/weights, multisig treasuries, time‑locks.
Privacy: Zero‑knowledge attestations for sensitive KPIs; per‑metric redaction.

What to read next: Doc 15 — Security Standards; Doc 16 — Privacy/ZK Patterns.

11 · Sustainability & Impact Hooks

pallet_sustainability.recordImpact(kind, amount, ref)
Treasury routes 1% (growing to 5%) via Stripe Climate; rotating EcoDrive campaigns programmable per territory.

What to read next: Doc 17 — Sustainability Module & API.

12 · Developer Environment & Tooling

12.1 Prereqs

Rust stable + nightly,

12.2 Build & Run

rustup target add wasm32-unknown-unknown
cargo build -p node --release
./target/release/chlom-node --dev

12.3 Testing

Unit tests (

What to read next: Doc 18 — Local Dev & Testing Guide.

13 · Deployment Topologies

DevNet: ephemeral, faucet enabled.
TestNet: permissioned validators, metrics, chaos testing.
MainNet: NPoS set; governance‑controlled upgrades; snapshot/backup SOPs.

What to read next: Doc 19 — Networks & Chain Specs; Doc 20 — Upgrade Playbook.

14 · SDKs & API Surfaces

TypeScript SDK: high‑level wrappers (
Rust Client: for indexers/oracle agents.
JSON‑RPC: standard Substrate plus custom
Example:

await api.tx.chlomLicensing.mint(classId, termsCid, scope).signAndSend(account)

What to read next: Doc 21 — TS SDK Reference; Doc 22 — Custom RPCs.

15 · Royalty Graph & Accounting Details

Weighted split DAG with cycle checks; rounding rules; currency adapters; batched payouts; dispute windows; proof receipts.

What to read next: Doc 23 — Royalty Engine Spec.

16 · KPI Catalogue & Measurement

Standard metric packs per vertical (e.g., suites: occupancy, rebook rate; media: completion rate; commerce: repeat purchase).
Windows: rolling 30/90; breach policies mapped to DLA sanctions.

What to read next: Doc 24 — KPI Library & Policies.

17 · LEX Market Microstructure

Order types (fixed, Dutch auction, sealed‑bid); partial equity; reserve prices; on‑chain escrow; oracle‑gated transfers.

What to read next: Doc 25 — LEX Market Design.

18 · DLA Case Management

Case lifecycle:

What to read next: Doc 26 — DLA Casebook.

19 · Cross‑Chain & Bridging

XCM for asset/command routing; guarded bridge policy; allowlist of audited bridges; rate limits.

What to read next: Doc 27 — Cross‑Chain Strategy.

20 · Compliance Packs by Jurisdiction

Pluggable rule packs per state/country; mapping tables; upgrade schedules; test matrices.

What to read next: Doc 28 — Regional Compliance Packs.

21 · Operational Runbooks (Validators & Governance)

Validator SRE handbook (monitoring, incident response, key rotation).
Governance ops (proposal templates, review SLAs, emergency playbook).

What to read next: Doc 29 — Validator Runbook; Doc 30 — Governance Ops Manual.

22 · Contribution, Versioning, and SLA

Semantic runtime versions; migration notes; state version bumps; deprecation policy; Help Center SLAs for doc updates after each runtime release.

What to read next: Doc 31 — Contributing & Release Process.

23 · Full Documentation Roadmap (30+ Items)

Substrate Runtime Setup Guide
Network & Keys Handbook (SS58, Sessions, Staking)
Licensing Protocol Spec
Compliance Protocol Spec
Governance Protocol Spec
Economic Protocol Spec
Pallet Design Deep Dives (per pallet)
Runtime Storage & Schemas
Sequence Diagrams & State Machines
Governance Parameters & Processes
Token Implementation & Fee Model
Oracle Gateway & Off‑chain Workers
Indexing Blueprints (SubQuery/Subsquid)
Observability & Telemetry (Prometheus/Otel)
Security Standards & Threat Model
Privacy & ZK Patterns
Sustainability Module & API
Local Dev & Testing Guide
Networks & Chain Specs
Upgrade Playbook (Forkless Upgrades)
TypeScript SDK Reference
Custom JSON‑RPC Extensions
Royalty Engine Spec
KPI Library & Policies
LEX Market Design
DLA Casebook & Sanction Matrix
Cross‑Chain Strategy (XCM/Bridges)
Regional Compliance Packs
Validator Runbook (SRE)
Governance Ops Manual
Disaster Recovery & Backups
Performance & Benchmarking (Weights)

24 · Final Notes for Help Center Editors

Keep this master up to date with each runtime release.
Every new pallet/upgrade must link back to this index and add a child doc entry.
Cross‑check examples against the repository CI snapshot before publishing.

Appendix A — Example Types (Rust)

pub struct LicenseTerms {
  pub jurisdiction: Vec<u8>,
  pub scope: Vec<u8>,
  pub royalty_model_id: u32,
  pub kpi_profile_id: u32,
  pub constraints: BoundedVec<Vec<u8>, ConstU32<8>>,
  pub terms_cid: Vec<u8>,
}

Appendix B — Example TS SDK Call

await api.tx.chlomLicensing.mint(classId, termsCid, scope).signAndSend(account, ({ status, events }) => { /* ... */ })

Disclaimer: Technical documentation; not legal advice. Always align deployments with applicable laws and the CHLOM Governance decisions.

Was this article helpful?