> For the complete documentation index, see [llms.txt](https://dominiumxyz.gitbook.io/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://dominiumxyz.gitbook.io/docs/learn/programmable-licensing.md).

# Programmable Licensing

How licensing terms become automatic and enforceable.

How Dominium makes licensing automatic, enforceable, and composable

***

{% hint style="warning" %}
**Under construction.** Dominium is currently in development.

These docs describe our vision and planned functionality.

Follow [@dominiumxyz](https://twitter.com/dominiumxyz) for official announcements.
{% endhint %}

***

## What is Programmable Licensing?

Traditional IP licensing requires lawyers, negotiations, contracts, and manual enforcement. Programmable licensing encodes all of these into smart contracts that execute automatically.

```
Traditional Licensing:
  Discovery → Negotiation → Lawyers → Contract → Manual Enforcement
  (weeks to months, high cost)

Programmable Licensing:
  Discovery → Click License → Smart Contract Executes
  (seconds, minimal cost)
```

***

## The Dominium License

Every IP Asset on Dominium has embedded licensing terms that define:

| Component        | Description                 |
| ---------------- | --------------------------- |
| **Permissions**  | What licensees can do       |
| **Restrictions** | What licensees cannot do    |
| **Pricing**      | How much it costs           |
| **Duration**     | How long the license lasts  |
| **Territories**  | Where the license applies   |
| **Royalties**    | Ongoing payment obligations |

### License Terms Structure

```solidity
struct LicenseTerms {
    // Permissions
    bool commercialUse;        // Can use for profit
    bool derivativeWorks;      // Can create derivatives
    bool aiTraining;           // Can use for AI training
    
    // Restrictions
    bool teeRequired;          // AI training must use TEE
    bool attributionRequired;  // Must credit owner
    
    // Pricing
    uint256 baseLicenseFee;    // One-time fee
    uint256 revenueShareBps;   // Ongoing royalty (basis points)
    
    // Duration
    uint256 duration;          // 0 = perpetual
    
    // Exclusivity
    bool exclusive;            // Only one licensee allowed
}
```

***

## License Lifecycle

### 1. Pre-License (IP Registration)

When you register IP, you define the license terms upfront.

### 2. License Acquisition

Licensees discover IP in the marketplace and acquire licenses with one click. Payment is automatic.

### 3. Active License Period

While active, the license NFT proves the holder's rights. Anyone can verify on-chain.

### 4. Post-License (Expiration/Revocation)

Licenses end through:

* **Expiration**: Duration elapsed
* **Revocation**: Terms violated
* **Unstaking**: Licensee stake dropped below threshold

***

## License Flavors

### Personal Use License

```javascript
{
  commercialUse: false,
  baseLicenseFee: 0,  // Free
  duration: 0,        // Perpetual
}
```

*Use case*: Fans can use character images for personal projects.

### Commercial License

```javascript
{
  commercialUse: true,
  derivativeWorks: true,
  baseLicenseFee: 10000,     // $10,000
  revenueShareBps: 500,      // 5%
  attributionRequired: true,
  duration: 31536000,        // 1 year
}
```

*Use case*: Game developer licenses a character for their game.

### AI Training License

```javascript
{
  commercialUse: true,
  aiTraining: true,
  teeRequired: true,         // Must use TEE
  baseLicenseFee: 50000,     // $50,000
  revenueShareBps: 1000,     // 10% of AI revenue
}
```

*Use case*: AI company trains image generation model on licensed artwork.

### Exclusive License

```javascript
{
  exclusive: true,
  baseLicenseFee: 1000000,   // $1,000,000
  revenueShareBps: 200,      // 2%
  duration: 94608000,        // 3 years
}
```

*Use case*: Major studio secures exclusive rights to a franchise.

***

## Enforcement Mechanisms

### On-Chain Enforcement

Smart contracts automatically enforce:

| Rule               | Enforcement                      |
| ------------------ | -------------------------------- |
| Payment collection | Automatic on license mint        |
| Expiration         | `isValidLicense()` returns false |
| Stake requirement  | License invalidated on unstake   |
| Exclusivity        | Cannot mint second license       |

### Economic Enforcement

Stake slashing penalizes violations. If someone violates terms, their staked tokens are confiscated.

### Legal Enforcement

The Dominium License Agreement provides real-world legal backing. Violation of on-chain terms constitutes breach of contract, enabling legal remedies.

***

## Royalty Collection

### How Royalties Work

1. License terms specify revenue share (e.g., 5%)
2. Licensee reports revenue
3. Smart contract calculates royalty
4. EIP-2612 permit enables automatic collection
5. IP Owner receives payment

### Example

```
Licensee Revenue: $100,000
Royalty Rate: 5% (500 bps)
Royalty Due: $5,000 → Automatically sent to IP Owner
```

***

## Composable Licensing

### Derivative Chains

Licenses can be combined and layered:

```
Original IP (Artist A)
    ├── License → Remix (Artist B)
    │                └── License → Game (Studio C)
    │
    └── License → AI Model (Company D)
```

Revenue flows back through the chain automatically.

***

## Best Practices

### For IP Owners

1. **Start permissive**: Enable commercial use, derivatives—more options = more licenses
2. **Use TEE requirement** for AI training: Protects your raw assets
3. **Set reasonable royalties**: 5-10% is typical; too high discourages licensing
4. **Offer multiple tiers**: Personal (free), Commercial (paid), Enterprise (premium)

### For Licensees

1. **Verify license scope**: Ensure your use case is covered
2. **Maintain stake**: Don't risk license invalidation
3. **Track royalty obligations**: Set up automated reporting
4. **Keep license NFT safe**: It's your proof of rights

***

## Next up

* Concrete examples: [Use cases](/docs/overview/use-cases.md)
* Architecture and components: [Platform](/docs/learn/platform.md)
* Integrate with the SDK/API: [Developers](/docs/build/developers.md)