resources/gdev.yaml

@@ -7,54 +7,55 @@ first_ud: null
 # null = block#0 + ud_reeval_period waiting (ms)
 first_ud_reeval: null
 
+# Parameters used in pallet `duniter-test-parameters`
 parameters:
   # Epoch (session) duration, in number of blocks. 1h.
   babe_epoch_duration: 600
   # Time between 2 UDs, in milliseconds. 4 hours.
   ud_creation_period: 14400000
-  # Time between 2 UD reevaluations, in milliseconds
+  # Time between 2 UD reevaluations, in milliseconds. 24 hours.
   ud_reeval_period: 86400000
 
   # ----- MAIN WOT -----
-  # Duration to wait between two emitted certifications, in blocks. 1 day.
+  # Duration to wait between two emitted certifications 14400 blocks = 24h = 1 day.
   cert_period: 14400
   # Maximum quantity of currently valid certifications emitted by a same issuer. 100 certs.
   cert_max_by_issuer: 100
   # Minimum quantity of received certifications to be able to certify someone else. 3 certs.
   cert_min_received_cert_to_issue_cert: 3
-  # Validity duration of a certification, in blocks. 146 days.
+  # Validity duration of a certification, 2102400 blocks = 146 days.
   cert_validity_period: 2102400
-  # Validity duration of a membership. 73 days.
+  # Validity duration of a membership. 1051200 blocks = 73 days.
   membership_period: 1051200
-  # Validity duration of a pending membership. 12 days.
+  # Validity duration of a pending membership. 172800 blocks = 12 days.
   pending_membership_period: 172800
-  # Delay (in blocks) a member must observe before being able to emit a certification
+  # Delay a new member must observe before being able to emit a certification
   wot_first_cert_issuable_on: 0
   # Number of required received certs to become a member
   wot_min_cert_for_membership: 3
-  # Time to wait between two creation of an identity by a same issue, in blocks. 1 day.
+  # Duration to wait between two identity creations. 14400 blocks = 24h = 1 day. (equal to cert_period)
   idty_creation_period: 14400
-  # Window to confirm an identity, in blocks. 1 day.
+  # Window to confirm an identity, in blocks. 14400 blocks = 24h = 1 day.
   idty_confirm_period: 14400
   # Number of required received certs to be able to create identities
   wot_min_cert_for_create_idty_right: 3
 
   # ----- SMITH WOT -----
-  # Duration to wait between two emitted certifications, in blocks. 1 day.
+  # Duration to wait between two emitted certifications, in blocks. 14400 blocks = 24h = 1 day.
   smith_cert_period: 14400
   # Maximum quantity of currently valid certifications emitted by a same issuer. 15 certs.
   smith_cert_max_by_issuer: 15
-  # Minimum quantity of received certifications to be able to certify someone else.
+  # Minimum quantity of smith certifications received to be able to smith certify someone else.
   smith_cert_min_received_cert_to_issue_cert: 3
-  # Validity duration of a certification, in blocks. 146 days.
+  # Validity duration of a certification, in blocks. 2102400 blocks = 146 days.
   smith_cert_validity_period: 2102400
-  # Validity duration of a membership. 73 days.
+  # Validity duration of a membership. 1051200 blocks = 73 days.
   smith_membership_period: 1051200
-  # Validity duration of a pending membership. 12 days.
+  # Validity duration of a pending membership. 172800 blocks = 12 days.
   smith_pending_membership_period: 172800
-  # Delay (in blocks) a member must observe before being able to emit a certification
+  # Delay a new smith member must observe before being able to emit a smith certification. 14400 blocks = 24h = 1 day.
   smith_wot_first_cert_issuable_on: 14400
-  # Number of required received certs to become a member
+  # Number of required received smith certs to become a smith member
   smith_wot_min_cert_for_membership: 3
 
 # Clique Smith WoT: each smith will certify by each other smith automatically on Genesis

runtime/common/src/weights/pallet_quota.rs

-// Copyright 2021-2022 Axiom-Team
-//
-// This file is part of Duniter-v2S.
-//
-// Duniter-v2S is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as published by
-// the Free Software Foundation, version 3 of the License.
-//
-// Duniter-v2S is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with Duniter-v2S. If not, see <https://www.gnu.org/licenses/>.
 
 //! Autogenerated weights for `pallet_quota`
 //!
 //! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
-//! DATE: 2023-10-26, STEPS: `5`, REPEAT: `2`, LOW RANGE: `[]`, HIGH RANGE: `[]`
+//! DATE: 2023-11-24, STEPS: `50`, REPEAT: `20`, LOW RANGE: `[]`, HIGH RANGE: `[]`
 //! WORST CASE MAP SIZE: `1000000`
-//! HOSTNAME: `Albatros`, CPU: `Intel(R) Core(TM) i7-8565U CPU @ 1.80GHz`
-//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("gdev-benchmark"), DB CACHE: 1024
+//! HOSTNAME: `bgallois-ms7d43`, CPU: `12th Gen Intel(R) Core(TM) i3-12100F`
+//! EXECUTION: None, WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024
 
 // Executed Command:
-// ./target/debug/duniter
+// ./target/release/duniter
 // benchmark
 // pallet
-// --chain=gdev-benchmark
-// --steps=5
-// --repeat=2
-// --pallet=pallet_quota
-// --extrinsic=*
-// --execution=wasm
+// --chain
+// dev
 // --wasm-execution=compiled
-// --heap-pages=4096
-// --output=./
-// --header=./file_header.txt
+// --pallet
+// pallet-quota
+// --extrinsic
+// *
+// --steps
+// 50
+// --repeat
+// 20
+// --output=runtime/common/src/weights/
 
 #![cfg_attr(rustfmt, rustfmt_skip)]
 #![allow(unused_parens)]
@@ -52,10 +39,10 @@ impl<T: frame_system::Config> pallet_quota::WeightInfo for WeightInfo<T> {
 	/// Proof: Quota RefundQueue (max_values: Some(1), max_size: Some(11266), added: 11761, mode: MaxEncodedLen)
 	fn queue_refund() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `42`
+		//  Measured:  `11288`
 		//  Estimated: `12751`
-		// Minimum execution time: 73_265_000 picoseconds.
-		Weight::from_parts(77_698_000, 0)
+		// Minimum execution time: 7_021_000 picoseconds.
+		Weight::from_parts(7_228_000, 0)
 			.saturating_add(Weight::from_parts(0, 12751))
 			.saturating_add(T::DbWeight::get().reads(1))
 			.saturating_add(T::DbWeight::get().writes(1))
@@ -64,32 +51,72 @@ impl<T: frame_system::Config> pallet_quota::WeightInfo for WeightInfo<T> {
 	/// Proof: Quota IdtyQuota (max_values: None, max_size: Some(24), added: 2499, mode: MaxEncodedLen)
 	fn spend_quota() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `137`
+		//  Measured:  `139`
 		//  Estimated: `3489`
-		// Minimum execution time: 147_746_000 picoseconds.
-		Weight::from_parts(165_850_000, 0)
+		// Minimum execution time: 3_635_000 picoseconds.
+		Weight::from_parts(3_768_000, 0)
 			.saturating_add(Weight::from_parts(0, 3489))
 			.saturating_add(T::DbWeight::get().reads(1))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
 	/// Storage: Quota IdtyQuota (r:1 w:1)
 	/// Proof: Quota IdtyQuota (max_values: None, max_size: Some(24), added: 2499, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:0)
+	/// Proof: System Account (max_values: None, max_size: Some(126), added: 2601, mode: MaxEncodedLen)
 	fn try_refund() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `137`
-		//  Estimated: `3489`
-		// Minimum execution time: 367_239_000 picoseconds.
-		Weight::from_parts(392_186_000, 0)
-			.saturating_add(Weight::from_parts(0, 3489))
-			.saturating_add(T::DbWeight::get().reads(1))
+		//  Measured:  `139`
+		//  Estimated: `3591`
+		// Minimum execution time: 11_415_000 picoseconds.
+		Weight::from_parts(11_717_000, 0)
+			.saturating_add(Weight::from_parts(0, 3591))
+			.saturating_add(T::DbWeight::get().reads(2))
 			.saturating_add(T::DbWeight::get().writes(1))
 	}
+	/// Storage: Quota IdtyQuota (r:1 w:1)
+	/// Proof: Quota IdtyQuota (max_values: None, max_size: Some(24), added: 2499, mode: MaxEncodedLen)
+	/// Storage: System Account (r:1 w:0)
+	/// Proof: System Account (max_values: None, max_size: Some(126), added: 2601, mode: MaxEncodedLen)
 	fn do_refund() -> Weight {
 		// Proof Size summary in bytes:
-		//  Measured:  `0`
-		//  Estimated: `0`
-		// Minimum execution time: 356_707_000 picoseconds.
-		Weight::from_parts(471_930_000, 0)
-			.saturating_add(Weight::from_parts(0, 0))
+		//  Measured:  `139`
+		//  Estimated: `3591`
+		// Minimum execution time: 10_849_000 picoseconds.
+		Weight::from_parts(11_263_000, 0)
+			.saturating_add(Weight::from_parts(0, 3591))
+			.saturating_add(T::DbWeight::get().reads(2))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: Quota RefundQueue (r:1 w:1)
+	/// Proof: Quota RefundQueue (max_values: Some(1), max_size: Some(11266), added: 11761, mode: MaxEncodedLen)
+	fn on_process_refund_queue() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `43`
+		//  Estimated: `12751`
+		// Minimum execution time: 1_530_000 picoseconds.
+		Weight::from_parts(1_646_000, 0)
+			.saturating_add(Weight::from_parts(0, 12751))
+			.saturating_add(T::DbWeight::get().reads(1))
+			.saturating_add(T::DbWeight::get().writes(1))
+	}
+	/// Storage: Quota RefundQueue (r:1 w:1)
+	/// Proof: Quota RefundQueue (max_values: Some(1), max_size: Some(11266), added: 11761, mode: Measured)
+	/// Storage: Quota IdtyQuota (r:1 w:1)
+	/// Proof: Quota IdtyQuota (max_values: None, max_size: Some(24), added: 2499, mode: Measured)
+	/// Storage: System Account (r:1 w:0)
+	/// Proof: System Account (max_values: None, max_size: Some(126), added: 2601, mode: Measured)
+	/// The range of component `i` is `[1, 256]`.
+	fn on_process_refund_queue_elements(i: u32, ) -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `164 + i * (44 ±0)`
+		//  Estimated: `3628 + i * (44 ±0)`
+		// Minimum execution time: 13_465_000 picoseconds.
+		Weight::from_parts(19_579_671, 0)
+			.saturating_add(Weight::from_parts(0, 3628))
+			// Standard Error: 1_313
+			.saturating_add(Weight::from_parts(465_028, 0).saturating_mul(i.into()))
+			.saturating_add(T::DbWeight::get().reads(3))
+			.saturating_add(T::DbWeight::get().writes(2))
+			.saturating_add(Weight::from_parts(0, 44).saturating_mul(i.into()))
 	}
 }

xtask/res/templates/runtime-errors.md

+# Runtime errors
+
+There are **{{error_counter}}** errors from **{{ pallets | length }}** pallets.
+
+<ul>
+{% for pallet in pallets -%}
+<li>{{ pallet.name }} - {{ pallet.index }}
+<ul>
+{% for error in pallet.errors -%}
+<li>
+<details>
+<summary>
+<code>{{ error.name }}</code> - {{ error.index }}</summary>
+{{ error.documentation }}
+</details>
+</li>
+{% endfor -%}
+</ul>
+</li>
+{% endfor -%}
+</ul>
\ No newline at end of file

xtask/res/templates/runtime-events.md

+# Runtime events
+
+There are **{{event_counter}}** events from **{{ pallets | length }}** pallets.
+
+<ul>
+{% for pallet in pallets -%}
+<li>{{ pallet.name }} - {{ pallet.index }}
+<ul>
+{% for event in pallet.events -%}
+<li>
+<details>
+<summary>
+<code>{{ event.name }}(
+{%- for param in event.params -%}
+{{ param.name }}{% if loop.last != true %}, {% endif %} 
+{%- endfor -%}
+)</code> - {{ event.index }}</summary>
+{{ event.documentation }}
+
+```rust
+{% for param in event.params -%}
+{{ param.name }}: {{ param.type_name }}
+{%- else -%}no args
+{% endfor -%}
+```
+
+</details>
+</li>
+{% endfor -%}
+</ul>
+</li>
+{% endfor -%}
+</ul>
\ No newline at end of file

xtask/src/gen_calls_doc.rs → xtask/src/gen_doc.rs

@@ -27,45 +27,98 @@ use tera::Tera;
 // consts
 
 const CALLS_DOC_FILEPATH: &str = "docs/api/runtime-calls.md";
+const EVENTS_DOC_FILEPATH: &str = "docs/api/runtime-events.md";
+const ERRORS_DOC_FILEPATH: &str = "docs/api/runtime-errors.md";
 const TEMPLATES_GLOB: &str = "xtask/res/templates/*.md";
 
 // define structs and implementations
 
-type RuntimeCalls = Vec<Pallet>;
+type RuntimePallets = Vec<Pallet>;
 
 #[derive(Clone, Serialize)]
 struct Pallet {
     index: u8,
     name: String,
     calls: Vec<Call>,
+    events: Vec<Event>,
+    errors: Vec<ErroR>,
+}
+#[derive(Clone, Serialize)]
+struct Call {
+    documentation: String,
+    index: u8,
+    name: String,
+    params: Vec<CallParam>,
+}
+#[derive(Clone, Serialize)]
+struct CallParam {
+    name: String,
+    type_name: String,
+}
+#[derive(Clone, Serialize)]
+struct Event {
+    documentation: String,
+    index: u8,
+    name: String,
+    params: Vec<EventParam>,
+}
+#[derive(Clone, Serialize)]
+struct EventParam {
+    name: String,
+    type_name: String,
+}
+#[derive(Clone, Serialize)]
+struct ErroR {
+    documentation: String,
+    index: u8,
+    name: String,
 }
 
 impl Pallet {
     fn new(
         index: u8,
         name: String,
-        scale_type_def: &scale_info::TypeDef<PortableForm>,
+        call_scale_type_def: &Option<scale_info::TypeDef<PortableForm>>,
+        event_scale_type_def: &Option<scale_info::TypeDef<PortableForm>>,
+        error_scale_type_def: &Option<scale_info::TypeDef<PortableForm>>,
     ) -> Result<Self> {
-        if let scale_info::TypeDef::Variant(calls_enum) = scale_type_def {
-            Ok(Self {
-                index,
-                name,
-                calls: calls_enum.variants.iter().map(Into::into).collect(),
-            })
+        let calls = if let Some(call_scale_type_def) = call_scale_type_def {
+            if let scale_info::TypeDef::Variant(calls_enum) = call_scale_type_def {
+                calls_enum.variants.iter().map(Into::into).collect()
+            } else {
+                bail!("Invalid metadata")
+            }
         } else {
-            bail!("Invalid metadata")
-        }
+            vec![]
+        };
+        let events = if let Some(event_scale_type_def) = event_scale_type_def {
+            if let scale_info::TypeDef::Variant(events_enum) = event_scale_type_def {
+                events_enum.variants.iter().map(Into::into).collect()
+            } else {
+                bail!("Invalid metadata")
+            }
+        } else {
+            vec![]
+        };
+        let errors = if let Some(error_scale_type_def) = error_scale_type_def {
+            if let scale_info::TypeDef::Variant(errors_enum) = error_scale_type_def {
+                errors_enum.variants.iter().map(Into::into).collect()
+            } else {
+                bail!("Invalid metadata")
+            }
+        } else {
+            vec![]
+        };
+        Ok(Self {
+            index,
+            name,
+            calls,
+            events,
+            errors,
+        })
     }
 }
 
-#[derive(Clone, Serialize)]
-struct Call {
-    documentation: String,
-    index: u8,
-    name: String,
-    params: Vec<CallParam>,
-}
-
 impl From<&scale_info::Variant<PortableForm>> for Call {
     fn from(variant: &scale_info::Variant<PortableForm>) -> Self {
         Self {
@@ -82,14 +135,26 @@ impl From<&scale_info::Variant<PortableForm>> for Call {
         }
     }
 }
-
-#[derive(Clone, Serialize)]
-struct CallParam {
-    name: String,
-    type_name: String,
+impl From<&scale_info::Field<PortableForm>> for CallParam {
+    fn from(field: &scale_info::Field<PortableForm>) -> Self {
+        Self {
+            name: field.clone().name.unwrap_or_default(),
+            type_name: field.clone().type_name.unwrap_or_default(),
+        }
+    }
 }
 
-impl From<&scale_info::Field<PortableForm>> for CallParam {
+impl From<&scale_info::Variant<PortableForm>> for Event {
+    fn from(variant: &scale_info::Variant<PortableForm>) -> Self {
+        Self {
+            documentation: variant.docs.iter().cloned().collect::<Vec<_>>().join("\n"),
+            index: variant.index,
+            name: variant.name.to_owned(),
+            params: variant.fields.iter().map(Into::into).collect(),
+        }
+    }
+}
+impl From<&scale_info::Field<PortableForm>> for EventParam {
     fn from(field: &scale_info::Field<PortableForm>) -> Self {
         Self {
             name: field.clone().name.unwrap_or_default(),
@@ -98,6 +163,16 @@ impl From<&scale_info::Field<PortableForm>> for CallParam {
     }
 }
 
+impl From<&scale_info::Variant<PortableForm>> for ErroR {
+    fn from(variant: &scale_info::Variant<PortableForm>) -> Self {
+        Self {
+            documentation: variant.docs.iter().cloned().collect::<Vec<_>>().join("\n"),
+            index: variant.index,
+            name: variant.name.to_owned(),
+        }
+    }
+}
+
 enum CallCategory {
     Disabled,
     Inherent,
@@ -149,7 +224,7 @@ impl CallCategory {
 }
 
 /// generate runtime calls documentation
-pub(super) fn gen_calls_doc() -> Result<()> {
+pub(super) fn gen_doc() -> Result<()> {
     // Read metadata
     let mut file = std::fs::File::open("resources/metadata.scale")
         .with_context(|| "Failed to open metadata file")?;
@@ -163,49 +238,100 @@ pub(super) fn gen_calls_doc() -> Result<()> {
 
     println!("Metadata successfully loaded!");
 
-    let runtime_calls = if let frame_metadata::RuntimeMetadata::V14(metadata_v14) = metadata.1 {
-        get_calls_from_metadata_v14(metadata_v14)?
+    let runtime = if let frame_metadata::RuntimeMetadata::V14(metadata_v14) = metadata.1 {
+        get_from_metadata_v14(metadata_v14)?
     } else {
         bail!("unsuported metadata version")
     };
 
-    let output = print_runtime_calls(runtime_calls);
+    let (call_doc, event_doc, error_doc) = print_runtime(runtime);
 
     let mut file = File::create(CALLS_DOC_FILEPATH)
         .with_context(|| format!("Failed to create file '{}'", CALLS_DOC_FILEPATH))?;
-    file.write_all(output.as_bytes())
+    file.write_all(call_doc.as_bytes())
         .with_context(|| format!("Failed to write to file '{}'", CALLS_DOC_FILEPATH))?;
+    let mut file = File::create(EVENTS_DOC_FILEPATH)
+        .with_context(|| format!("Failed to create file '{}'", EVENTS_DOC_FILEPATH))?;
+    file.write_all(event_doc.as_bytes())
+        .with_context(|| format!("Failed to write to file '{}'", EVENTS_DOC_FILEPATH))?;
+    let mut file = File::create(ERRORS_DOC_FILEPATH)
+        .with_context(|| format!("Failed to create file '{}'", ERRORS_DOC_FILEPATH))?;
+    file.write_all(error_doc.as_bytes())
+        .with_context(|| format!("Failed to write to file '{}'", ERRORS_DOC_FILEPATH))?;
 
     Ok(())
 }
 
-fn get_calls_from_metadata_v14(
+fn get_from_metadata_v14(
     metadata_v14: frame_metadata::v14::RuntimeMetadataV14,
-) -> Result<RuntimeCalls> {
+) -> Result<RuntimePallets> {
     println!("Number of pallets: {}", metadata_v14.pallets.len());
     let mut pallets = Vec::new();
     for pallet in metadata_v14.pallets {
-        if let Some(calls) = pallet.calls {
-            if let Some(calls_type) = metadata_v14.types.resolve(calls.ty.id) {
-                let pallet = Pallet::new(pallet.index, pallet.name.clone(), &calls_type.type_def)?;
-                let calls_len = pallet.calls.len();
-                println!("{}: {} ({} calls)", pallet.index, pallet.name, calls_len);
-                pallets.push(pallet);
-            } else {
+        let calls_type_def = if let Some(calls) = pallet.calls {
+            let Some(calls_type) = metadata_v14.types.resolve(calls.ty.id) else {
                 bail!("Invalid metadata")
-            }
+            };
+            Some(calls_type.type_def.clone())
         } else {
             println!("{}: {} (0 calls)", pallet.index, pallet.name);
-        }
+            None
+        };
+        let events_type_def = if let Some(events) = pallet.event {
+            let Some(events_type) = metadata_v14.types.resolve(events.ty.id) else {
+                bail!("Invalid metadata")
+            };
+            Some(events_type.type_def.clone())
+        } else {
+            println!("{}: {} (0 events)", pallet.index, pallet.name);
+            None
+        };
+        let errors_type_def = if let Some(errors) = pallet.error {
+            let Some(errors_type) = metadata_v14.types.resolve(errors.ty.id) else {
+                bail!("Invalid metadata")
+            };
+            Some(errors_type.type_def.clone())
+        } else {
+            println!("{}: {} (0 errors)", pallet.index, pallet.name);
+            None
+        };
+
+        let pallet = Pallet::new(
+            pallet.index,
+            pallet.name.clone(),
+            &calls_type_def,
+            &events_type_def,
+            &errors_type_def,
+        )?;
+
+        println!(
+            "{}: {} ({} calls)",
+            pallet.index,
+            pallet.name,
+            pallet.calls.len()
+        );
+        println!(
+            "{}: {} ({} events)",
+            pallet.index,
+            pallet.name,
+            pallet.events.len()
+        );
+        println!(
+            "{}: {} ({} errors)",
+            pallet.index,
+            pallet.name,
+            pallet.errors.len()
+        );
+        pallets.push(pallet);
     }
     Ok(pallets)
 }
 
 /// use template to render markdown file with runtime calls documentation
-fn print_runtime_calls(pallets: RuntimeCalls) -> String {
+fn print_runtime(pallets: RuntimePallets) -> (String, String, String) {
     // init variables
     let mut user_calls_counter = 0;
-    let user_calls_pallets: RuntimeCalls = pallets
+    let user_calls_pallets: RuntimePallets = pallets
         .iter()
         .cloned()
         .filter_map(|mut pallet| {
@@ -222,7 +348,7 @@ fn print_runtime_calls(pallets: RuntimeCalls) -> String {
         })
         .collect();
     let mut root_calls_counter = 0;
-    let root_calls_pallets: RuntimeCalls = pallets
+    let root_calls_pallets: RuntimePallets = pallets
         .iter()
         .cloned()
         .filter_map(|mut pallet| {
@@ -239,7 +365,7 @@ fn print_runtime_calls(pallets: RuntimeCalls) -> String {
         })
         .collect();
     let mut disabled_calls_counter = 0;
-    let disabled_calls_pallets: RuntimeCalls = pallets
+    let disabled_calls_pallets: RuntimePallets = pallets
         .iter()
         .cloned()
         .filter_map(|mut pallet| {
@@ -256,6 +382,16 @@ fn print_runtime_calls(pallets: RuntimeCalls) -> String {
         })
         .collect();
 
+    let mut event_counter = 0;
+    pallets
+        .iter()
+        .for_each(|pallet| event_counter += pallet.events.len());
+
+    let mut error_counter = 0;
+    pallets
+        .iter()
+        .for_each(|pallet| error_counter += pallet.errors.len());
+
     // compile template
     let tera = match Tera::new(TEMPLATES_GLOB) {
         Ok(t) => t,
@@ -265,7 +401,7 @@ fn print_runtime_calls(pallets: RuntimeCalls) -> String {
         }
     };
 
-    // fills tera context for rendering
+    // fills tera context for rendering calls
     let mut context = tera::Context::new();
     context.insert("user_calls_counter", &user_calls_counter);
     context.insert("user_calls_pallets", &user_calls_pallets);
@@ -274,6 +410,22 @@ fn print_runtime_calls(pallets: RuntimeCalls) -> String {
     context.insert("disabled_calls_counter", &disabled_calls_counter);
     context.insert("disabled_calls_pallets", &disabled_calls_pallets);
 
-    tera.render("runtime-calls.md", &context)
-        .expect("template error")
+    let call_doc = tera
+        .render("runtime-calls.md", &context)
+        .expect("template error");
+
+    // render events
+    context.insert("pallets", &pallets);
+    context.insert("event_counter", &event_counter);
+    let event_doc = tera
+        .render("runtime-events.md", &context)
+        .expect("template error");
+
+    // render errors
+    context.insert("error_counter", &error_counter);
+    let error_doc = tera
+        .render("runtime-errors.md", &context)
+        .expect("template error");
+
+    (call_doc, event_doc, error_doc)
 }

xtask/src/main.rs

@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with Duniter-v2S. If not, see <https://www.gnu.org/licenses/>.
 
-mod gen_calls_doc;
+mod gen_doc;
 mod release_runtime;
 
 use anyhow::{Context, Result};
@@ -38,8 +38,8 @@ enum DuniterXTaskCommand {
         #[clap(long)]
         production: bool,
     },
-    /// Generate calls documentation
-    GenCallsDoc,
+    /// Generate documentation (calls and events)
+    GenDoc,
     /// Inject runtime code in raw specs
     InjectRuntimeCode {
         #[clap(short, long)]
@@ -82,7 +82,7 @@ async fn main() -> Result<()> {
 
     match args.command {
         DuniterXTaskCommand::Build { production } => build(production),
-        DuniterXTaskCommand::GenCallsDoc => gen_calls_doc::gen_calls_doc(),
+        DuniterXTaskCommand::GenDoc => gen_doc::gen_doc(),
         DuniterXTaskCommand::InjectRuntimeCode { runtime, raw_spec } => {
             inject_runtime_code(&raw_spec, &runtime)
         }