CHLOM™ Ownership Master Technical Document

Version 1.0 — Issued by CrownThrive, LLC “Rights, Equity, and the Roadmap for Tokenized Ownership in the Decentralized Licensing & Compliance Layer.”

Audience: Product architects, tokenization engineers, legal/ops leads, LEX market designers, validator operators, integrators, and Help Center editors curating the CHLOM Ownership category. Scope: Canonical reference for what CHLOM Ownership is, how it’s modeled and encoded, 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 for ownership and equity flows.
Each section ends with “What to read next” cross‑links into the Ownership category.
Code examples are illustrative; the authoritative source is the runtime repository, LEX specs, and governance records.

1 · System Overview

CHLOM™ Ownership defines how rights, equity, and economic interests are represented, transferred, fractionalized, vested, and enforced across the ecosystem. Ownership is realized as License NFTs + Fractional Units (FUs) with on‑chain royalty entitlements, governance hooks, and compliance constraints. The ownership layer powers cap tables, ROFR/ROFO, buybacks, collateralization, inheritance, and liquidation.

1.1 High‑Level Architecture

+--------------------------+      +--------------------+      +---------------------------+
|  Business Apps & Consoles|<---->|  API Gateway / WS  |<---->| Reference Chain (Runtime) |
|  (Cap Table, LEX, Ops)   |      |  (REST/WS/RPC)     |      | FRAME Pallets             |
+--------------------------+      +--------------------+      +---------------------------+
                                                                | licensing / ownership    |
+--------------------------+      +--------------------+        | royalty / lex / dla      |
|  Data & Analytics        |<---->|  Indexers          |        | gov / oracle / vesting   |
|  (Cap Tables, BI)        |      |  (SubQuery/Squid)  |        | attest / sustainability  |
+--------------------------+      +--------------------+        +---------------------------+

+--------------------------+      +--------------------+
|  Oracles & Off‑chain     |<---->|  OCWs + Gateways   |
|  (KYC, Pricing, POS/IoT) |      |  (signed feeds)    |
+--------------------------+      +--------------------+

1.2 Consensus & Accounts

Framework is chain‑agnostic; the reference chain uses:

Consensus: BABE + GRANDPA.
Staking: NPoS (
Accounts: SS58, sr25519/ed25519; multisig via

What to read next: Doc 01 — Ownership Conceptual Model; Doc 02 — Network & Keys Handbook.

2 · Core Protocols (Functional Specs)

2.1 Ownership Protocol (OP)

Defines License NFTs as primary rights containers and Fractional Units (FUs) as fungible/non‑fungible slices of economic interest and/or governance.

Extrinsics (examples):

ownership.fractionalize(item_id, model, granularity_bps)
ownership.merge(item_id, unit_ids[])
ownership.split(unit_id, bps)
ownership.transfer(unit_id, to)

Storage: cap table snapshots per license; FU registry; ROFR/ROFO policies; vesting references; lien/collateral records.

2.2 Vesting & Lockups Protocol (VLP)

Time/condition‑based schedules for FUs and operator grants.

vesting.grant(unit_id, to, schedule)
vesting.release(grant_id)
vesting.clawback(grant_id, cause)

2.3 Rights of First Refusal/Offer (ROFR/ROFO)

Policy‑gated transfers with timed windows and on‑chain offers.

ownership.registerRofr(item_id, policy)
ownership.exerciseRofr(unit_id)
ownership.waiveRofr(unit_id)

2.4 Collateralization & Lien Protocol (CLP)

Use FUs as collateral, with oracle‑backed valuations and liquidation.

collateral.pledge(unit_id, lender, terms)
collateral.release(pledge_id)
collateral.liquidate(pledge_id)

What to read next: Doc 03 — Ownership Protocol Spec; Doc 04 — Vesting & Lockups Spec; Doc 05 — ROFR/ROFO Spec; Doc 06 — Collateralization Spec.

3 · Runtime Pallets (FRAME)

Pallet	Purpose	Key Storage	Key Extrinsics	Events/Errors
`pallet_chlom_licensing`	Mint/amend/revoke License NFTs	Licenses, TermsCID	`mint`, `amend`, `revoke`	`LicenseMinted`
`pallet_chlom_ownership`	Fractional units, cap table	FUs, CapTable, Policies	`fractionalize`, `split`, `merge`, `transfer`	`UnitSplit`, `UnitMerged`
`pallet_chlom_vesting`	Grants, cliffs, lockups	Grants, Schedules	`grant`, `release`, `clawback`	`GrantReleased`
`pallet_chlom_rofr`	ROFR/ROFO policy & actions	Policies, Offers	`registerRofr`, `exerciseRofr`	`RofrExercised`
`pallet_chlom_royalty`	Royalty graph & payouts	Splits, Accruals	`route`, `settle`	`RoyaltySettled`
`pallet_chlom_lex`	Exchange for License/FUs	Orders, Escrows	`list`, `buy`, `partialSell`, `cancel`	`TradeSettled`
`pallet_chlom_dla`	Disputes & sanctions	Cases, Sanctions	`openCase`, `applySanction`, `resolve`	`SanctionApplied`
`pallet_oracle_gateway`	Pricing & compliance oracles	Feeds, Sigs	`registerFeed`, `attest`	`Attested`
`pallet_attestations`	Evidence registry	Proofs	`submitProof`	`ProofRecorded`
`pallet_reputation`	Operator/issuer scores	Scores	`updateScore`	`ReputationUpdated`
`pallet_sustainability`	Impact ledger & offsets	Impacts, Routes	`recordImpact`, `routeOffset`	`ImpactRecorded`

What to read next: Doc 07 — Pallet Design Deep Dives (Ownership Set).

4 · Data Model & Schemas

OwnershipUnit (FU):
CapTable:
VestingSchedule:
RofrPolicy:
Pledge/Lien:

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

5 · Protocol Flows (Sequence Specs)

5.1 Fractionalization

Mint license → call ownership.fractionalize → create FUs at granularity (e.g., 1 bps) → initialize cap table → optional vesting.

5.2 Transfer & ROFR Flow

Seller lists FU on LEX → rofr window opens → eligible parties exercise/waive → sale clears or cancels → cap table updates.

5.3 Collateral Pledge & Liquidation

FU pledged → oracle valuation + LTV → loan issued → breach triggers liquidation auction on LEX → proceeds settle lender and return remainder.

5.4 Inheritance & Succession

Owner sets successor (on‑chain nomination) → estate event triggers transfer after probate delay → vesting/lockups preserved.

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

6 · Governance & DAO Mechanics

Ownership policies (granularity, rights masks, ROFR defaults, vesting templates) are DAO‑governed. Reputation boosts for compliant issuers; penalties for repeated breaches. Emergency council may freeze transfers on specific licenses or classes subject to post‑hoc referendum.

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

7 · Token Model (Runtime View)

CHM (governance): stake, vote, validator rewards; influence over ownership policy changes.
CHLOM (utility): fees for fractionalization, transfer, vesting ops, escrow; fee‑burn/buyback hooks; bonding for new issuances; slashing on fraudulent issuance confirmed by DLA.

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

8 · Oracles & Off‑Chain Workers

Pricing oracles (comparables, cashflow, KPI‑derived models); compliance feeds (KYC/KYB); POS/IoT signals for revenue‑backed valuations. OCWs batch cap table snapshots, valuation updates, and vesting releases with signed attestations.

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

9 · Indexing & Analytics

Index FUs, cap tables, vesting, pledges/liens, ROFR events, LEX trades. Dashboards include ownership concentration, lockup schedules, dilution alerts, and payout history. Prometheus/Otel for ownership pallet metrics.

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

10 · Security, Privacy, and Compliance

Threats: double‑spend of FUs, stale cap tables, ROFR race conditions, escrow reentrancy, oracle spoofing. Controls: audited pallets, non‑reentrant escrows, atomic cap table updates, commit‑reveal where needed, time‑locks for policy changes, multisig treasury, ZK‑proofs for sensitive holder info.

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

11 · Sustainability & Impact Hooks

Ownership events can route 1% (scaling to 5%) to Stripe Climate; EcoDrive campaigns rotate by territory; recordImpact(kind, amount, ref) logs trees planted, ocean plastic removed, jobs created, etc., linked to ownership activity.

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

12 · Developer Environment & Tooling

12.1 Prereqs

Rust stable + nightly; wasm32-unknown-unknown; Substrate node template; subkey; Docker; Polkadot‑JS Apps; local mock price oracle.

12.2 Build & Run (Reference Chain)

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

12.3 Testing

Unit/integration tests; try-runtime; proptest and fuzzing; scenario tests for ROFR windows, vesting, pledges/liens, inheritance transfers.

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

13 · Deployment Topologies

DevNet (ephemeral/faucet; mock pricing oracle); TestNet (permissioned oracle feeds; chaos tests); MainNet (oracle SLAs; governed policy updates; snapshots/backups; incident response SOPs).

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

14 · SDKs & API Surfaces

TypeScript SDK (high‑level wrappers), Rust client (indexers/oracles), JSON‑RPC (standard + ownership_*).

Example:

await api.tx.chlomOwnership.fractionalize(itemId, { model: 'proportional', granularity_bps: 1 })
  .signAndSend(account)

What to read next: Doc 21 — TS SDK Reference; Doc 22 — Custom JSON‑RPC Extensions.

15 · Royalty Graph & Ownership Payouts

Royalty DAG distributes to FU holders pro‑rata; rounding/lottery rules for dust; dispute windows; Merkle receipts for audits; escrow holds on DLA flags.

What to read next: Doc 23 — Royalty Engine Spec (Ownership Interop).

16 · KPI Catalogue & Measurement (Ownership Context)

KPI packs that feed valuations and bonus emissions (e.g., occupancy, retention, ARPU, completion rate). Windows: rolling 30/90; thresholds drive vesting accelerations or clawbacks per policy.

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

17 · LEX Market Microstructure (Ownership)

Order types for FUs (fixed/Dutch/sealed‑bid); partial equity; reserve prices; on‑chain escrow; oracle‑gated transfers; anti‑MEV measures (commit‑reveal). Listings respect ROFR/lockups automatically.

What to read next: Doc 25 — LEX Market Design (Ownership Edition).

18 · DLA Case Management (Ownership)

Disputes: fraudulent issuance, cap table tampering, ROFR violations, pledge fraud. Case lifecycle with evidence chains, sanctions (void, clawback, fines), appeals, and public redaction policy.

What to read next: Doc 26 — DLA Casebook & Sanction Matrix.

19 · Cross‑Chain & Bridging (Ownership Tokens)

XCM for FU/License movement; bridge allowlist; jurisdiction constraints; rate limits; circuit breakers for mass transfers; mapping tables for foreign asset IDs.

What to read next: Doc 27 — Cross‑Chain Strategy (Ownership Tokens).

20 · Compliance Packs by Jurisdiction (Ownership)

Pluggable rule packs with securities‑sensitive constraints (transfer restrictions, disclosures, accredited gates), version calendars, conflict‑of‑law fallbacks.

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

21 · Operational Runbooks (Ownership Registrar & Governance)

Registrar ops (issuance QA, cap table reconciliation, ROFR window service levels). Governance ops (policy updates, change control, incident response).

What to read next: Doc 29 — Registrar/Validator Runbook (SRE); Doc 30 — Governance Ops Manual.

22 · Contribution, Versioning, and SLA

Semantic versions; migration notes; state version bumps; deprecation policy; documentation SLAs; change approval via governance.

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

23 · Full Documentation Roadmap (30+ Items)

Ownership Conceptual Model
Network & Keys Handbook (SS58, Sessions, Staking)
Ownership Protocol Spec
Vesting & Lockups Spec
ROFR/ROFO Spec
Collateralization Spec
Pallet Design Deep Dives (Ownership Set)
Runtime Storage & Schemas (Ownership)
Sequence Diagrams & State Machines (Ownership)
Governance Parameters & Processes (Ownership)
Token Implementation & Fee Model (Ownership)
Oracle Gateway & OCW Patterns (Ownership)
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 (Ownership Interop)
KPI Library & Policies
LEX Market Design (Ownership Edition)
DLA Casebook & Sanction Matrix
Cross‑Chain Strategy (Ownership Tokens)
Regional Compliance Packs (Ownership)
Registrar/Validator Runbook (SRE)
Governance Ops Manual
Disaster Recovery & Backups
Performance & Benchmarking (Weights)

24 · Final Notes for Help Center Editors

Keep this master current with each runtime and governance release.
Every new module/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 OwnershipUnit { pub unit_id: u128, pub parent_item_id: u128, pub owner: AccountId32, pub bps: u16, pub rights_mask: u32, pub vesting_id: Option<u64>, pub lien_id: Option<u64>, pub policy_ref: u32 }
pub struct CapTableEntry { pub holder: AccountId32, pub bps: u16, pub units: BoundedVec<u128, ConstU32<64>> }
pub struct VestingSchedule { pub grant_id: u64, pub unit_id: u128, pub beneficiary: AccountId32, pub cliff: u32, pub periods: u32, pub amount_bps: u16, pub conditions: Vec<u8> }

Appendix B — Example TS SDK Call

await api.tx.chlomOwnership.fractionalize(itemId, { model: 'proportional', granularity_bps: 1 })
  .signAndSend(account, ({ status, events }) => { /* ... */ })

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

Was this article helpful?