frame-suite 0.1.1

Core traits, semantic abstractions, and foundational interfaces for the FRAME Suite runtime architecture
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

# FRAME Suite

A composable, type-driven foundation for building modular runtime systems on Substrate.

FRAME Suite is a collection of reusable, **fully generic abstractions** for expressing common runtime patterns.

It is built around a simple idea:

> Build runtimes as compositions of semantics, not implementations.

Instead of coupling storage, logic, and structure, FRAME Suite separates them into **traits, types, and pluggable execution**, allowing systems to remain flexible, extensible, and reusable across pallets.

## Core Ideas

* **Generic by design**: all components are abstract and type-driven
* **Plugin-based execution**: is defined via pluggable models
* **Virtual structures**: data is described by schema, not fixed layout
* **Routine-driven workflows**: structured offchain execution with best-effort guarantees

These principles enable building systems that evolve without redesign.

## Usage

FRAME Suite is **not a pallet**, it is meant to be used inside your pallets.

Add dependency:

```toml
[dependencies]
frame-suite = { path = "../frame-suite", default-features = false }
```

Import modules:

```rust
use frame_suite::{assets::*, commitment::*, xp::*};
```

Implement traits:

```rust
pub struct MyBalance;

impl LazyBalance for MyBalance {
    type Asset = Balance;
    type Rational = FixedU128;
    type Time = BlockNumber;
}
```

Use in dispatchables:

```rust
pub fn deposit(origin, amount: Balance) -> DispatchResult {
    let who = ensure_signed(origin)?;
    // integrate FRAME Suite logic
    Ok(())
}
```

## Composition

FRAME Suite modules are designed to interoperate:

* `assets` + `commitment` : **staking, escrow, bonded systems**
* `xp` + `roles` : **reputation-driven roles and governance**
* `blockchain` + `elections` : **validator lifecycle and rewards**
* `accumulators` + `xp` : **progression and leveling systems**
* `virtuals` + `plugins` : **logic and structural extensibility**
* `forks` + `routines` : **best-effork fork-aware offchain workers**

Complex systems emerge by composing small, orthogonal primitives.

## Notes

* No storage is imposed, defined by the implementing pallet
* No genesis configuration, handled by the runtime
* No extrinsics, exposed through your pallet

## License

MPL-2.0 (Mozilla Public License)

An Open-Source initiative by **Auguth Labs (OPC) Pvt Ltd, India**