2403 lines
72 KiB
Markdown
2403 lines
72 KiB
Markdown
# Implémentation d'une DAO sur 4NK : Spécification Technique
|
|
|
|
**Version:** 1.0
|
|
**Date:** 1 octobre 2025
|
|
**Prérequis:** [4NK_IDENTITY_AND_PROCESS_SPEC.md](./4NK_IDENTITY_AND_PROCESS_SPEC.md)
|
|
|
|
---
|
|
|
|
## Table des matières
|
|
|
|
1. [Architecture d'une DAO 4NK](#1-architecture-dune-dao-4nk)
|
|
2. [Mécanismes de gouvernance](#2-mécanismes-de-gouvernance)
|
|
3. [Système de vote on-chain](#3-système-de-vote-on-chain)
|
|
4. [Gestion de trésorerie](#4-gestion-de-trésorerie)
|
|
5. [Propositions et exécution](#5-propositions-et-exécution)
|
|
6. [Tokenisation et pondération](#6-tokenisation-et-pondération)
|
|
7. [Sécurité et attaques](#7-sécurité-et-attaques)
|
|
8. [Implémentation de référence](#8-implémentation-de-référence)
|
|
|
|
---
|
|
|
|
## 1. Architecture d'une DAO 4NK
|
|
|
|
### 1.1 Vue d'ensemble
|
|
|
|
Une DAO (Decentralized Autonomous Organization) sur 4NK exploite les primitives existantes pour créer une organisation autonome avec:
|
|
|
|
- **Gouvernance on-chain** via ProcessState
|
|
- **Identité cryptographique** via Silent Payments
|
|
- **Consensus distribué** via ValidationRules
|
|
- **Trésorerie Bitcoin** via UTXO management
|
|
- **Auditabilité complète** via blockchain commitments
|
|
|
|
```
|
|
┌────────────────────────────────────────────────────────────┐
|
|
│ DAO 4NK │
|
|
├────────────────────────────────────────────────────────────┤
|
|
│ │
|
|
│ GOUVERNANCE TRÉSORERIE │
|
|
│ ┌─────────────┐ ┌─────────────┐ │
|
|
│ │ Processus │ │ Multisig │ │
|
|
│ │ de vote │ │ UTXO Pool │ │
|
|
│ └──────┬──────┘ └──────┬──────┘ │
|
|
│ │ │ │
|
|
│ │ ┌──────────────┐ │ │
|
|
│ └─►│ Proposition │◄───────┘ │
|
|
│ │ Executable │ │
|
|
│ └──────┬───────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ ┌────────────────────┐ │
|
|
│ │ Exécution on-chain│ │
|
|
│ │ (Bitcoin Tx) │ │
|
|
│ └────────────────────┘ │
|
|
│ │
|
|
│ MEMBRES │
|
|
│ ┌──────────┬──────────┬──────────┐ │
|
|
│ │ Founder │ Member │ Delegate │ │
|
|
│ │ (100%) │ (1 vote) │ (N votes)│ │
|
|
│ └──────────┴──────────┴──────────┘ │
|
|
└────────────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
### 1.2 Composants techniques
|
|
|
|
#### A. Processus DAO principal
|
|
|
|
```rust
|
|
pub struct DaoProcess {
|
|
// Processus 4NK contenant la gouvernance
|
|
process: Process,
|
|
|
|
// Configuration de la DAO
|
|
config: DaoConfig,
|
|
|
|
// État actuel
|
|
current_state: DaoState,
|
|
}
|
|
|
|
pub struct DaoConfig {
|
|
// Nom de la DAO
|
|
name: String,
|
|
|
|
// Type de vote
|
|
voting_system: VotingSystem,
|
|
|
|
// Quorum requis (0.0 à 1.0)
|
|
quorum: f32,
|
|
|
|
// Durée de vote (en blocs Bitcoin)
|
|
voting_period_blocks: u32,
|
|
|
|
// Délai d'exécution (timelock)
|
|
execution_delay_blocks: u32,
|
|
|
|
// Trésorerie
|
|
treasury_address: SilentPaymentAddress,
|
|
}
|
|
|
|
pub struct DaoState {
|
|
// Membres de la DAO
|
|
members: HashMap<OutPoint, MemberInfo>,
|
|
|
|
// Propositions actives
|
|
active_proposals: Vec<Proposal>,
|
|
|
|
// Propositions exécutées
|
|
executed_proposals: Vec<ProposalExecution>,
|
|
|
|
// Balance de trésorerie
|
|
treasury_balance: Amount,
|
|
}
|
|
```
|
|
|
|
#### B. Structure de membre DAO
|
|
|
|
```rust
|
|
pub struct MemberInfo {
|
|
// Pairing process ID du membre
|
|
member_id: OutPoint,
|
|
|
|
// Adresses Silent Payment
|
|
sp_addresses: Vec<SilentPaymentAddress>,
|
|
|
|
// Poids de vote (tokens)
|
|
voting_power: u64,
|
|
|
|
// Délégation (optionnel)
|
|
delegated_to: Option<OutPoint>,
|
|
|
|
// Date d'adhésion (hauteur de bloc)
|
|
joined_at: u32,
|
|
|
|
// Récompenses accumulées
|
|
rewards: Amount,
|
|
}
|
|
|
|
impl MemberInfo {
|
|
pub fn effective_voting_power(&self, state: &DaoState) -> u64 {
|
|
if let Some(delegate) = self.delegated_to {
|
|
0 // Votes délégués
|
|
} else {
|
|
// Inclure les votes délégués à ce membre
|
|
let delegated_votes: u64 = state.members.values()
|
|
.filter(|m| m.delegated_to == Some(self.member_id))
|
|
.map(|m| m.voting_power)
|
|
.sum();
|
|
|
|
self.voting_power + delegated_votes
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
### 1.3 Processus fondamentaux
|
|
|
|
Une DAO 4NK repose sur **trois processus distincts** :
|
|
|
|
```
|
|
┌─────────────────────────────────────────────────────┐
|
|
│ Processus 1: GOUVERNANCE │
|
|
│ ├─ États: Propositions, Votes, Paramètres │
|
|
│ ├─ Rôles: Founders, Members, Delegates │
|
|
│ └─ Validations: Quorum-based │
|
|
└─────────────────────────────────────────────────────┘
|
|
│
|
|
▼ Référence via process_id
|
|
┌─────────────────────────────────────────────────────┐
|
|
│ Processus 2: TRÉSORERIE (Multisig) │
|
|
│ ├─ États: UTXO pool, Dépenses │
|
|
│ ├─ Rôles: Signataires (M-of-N) │
|
|
│ └─ Validations: Signatures cryptographiques │
|
|
└─────────────────────────────────────────────────────┘
|
|
│
|
|
▼ Référence via execution_id
|
|
┌─────────────────────────────────────────────────────┐
|
|
│ Processus 3: ADHÉSIONS (Pairing collectif) │
|
|
│ ├─ États: Liste des membres │
|
|
│ ├─ Rôles: Admission committee │
|
|
│ └─ Validations: Vote d'admission │
|
|
└─────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
**Avantages de cette architecture:**
|
|
|
|
- **Séparation des responsabilités** : Gouvernance ≠ Trésorerie
|
|
- **Évolutivité** : Chaque processus peut évoluer indépendamment
|
|
- **Sécurité** : Compromission d'un processus n'affecte pas les autres
|
|
- **Auditabilité** : Traçabilité complète de chaque aspect
|
|
|
|
---
|
|
|
|
## 2. Mécanismes de gouvernance
|
|
|
|
### 2.1 Types de vote
|
|
|
|
#### A. Vote simple (1 membre = 1 vote)
|
|
|
|
```rust
|
|
pub enum VotingSystem {
|
|
Simple, // 1 membre = 1 vote
|
|
Weighted, // Vote pondéré par tokens
|
|
Quadratic, // Vote quadratique (√tokens)
|
|
Delegated, // Délégation de votes
|
|
Reputation, // Basé sur la réputation
|
|
}
|
|
|
|
impl VotingSystem {
|
|
pub fn calculate_vote_power(&self, member: &MemberInfo, state: &DaoState) -> u64 {
|
|
match self {
|
|
VotingSystem::Simple => 1,
|
|
VotingSystem::Weighted => member.effective_voting_power(state),
|
|
VotingSystem::Quadratic => {
|
|
let power = member.effective_voting_power(state);
|
|
(power as f64).sqrt() as u64
|
|
},
|
|
VotingSystem::Delegated => {
|
|
if member.delegated_to.is_some() {
|
|
0
|
|
} else {
|
|
member.effective_voting_power(state)
|
|
}
|
|
},
|
|
VotingSystem::Reputation => {
|
|
self.calculate_reputation(member, state)
|
|
},
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
#### B. Vote pondéré par tokens
|
|
|
|
**Cas d'usage:** DAOs avec investisseurs (proportionnel à l'investissement)
|
|
|
|
```rust
|
|
pub struct TokenWeightedVote {
|
|
// Total de tokens en circulation
|
|
total_supply: u64,
|
|
|
|
// Tokens détenus par membre
|
|
balances: HashMap<OutPoint, u64>,
|
|
}
|
|
|
|
impl TokenWeightedVote {
|
|
pub fn vote_power(&self, member_id: &OutPoint) -> f32 {
|
|
let tokens = self.balances.get(member_id).unwrap_or(&0);
|
|
(*tokens as f32) / (self.total_supply as f32)
|
|
}
|
|
|
|
pub fn has_quorum(&self, votes: &HashMap<OutPoint, Vote>, quorum: f32) -> bool {
|
|
let voted_tokens: u64 = votes.keys()
|
|
.filter_map(|member_id| self.balances.get(member_id))
|
|
.sum();
|
|
|
|
let participation = (voted_tokens as f32) / (self.total_supply as f32);
|
|
participation >= quorum
|
|
}
|
|
}
|
|
```
|
|
|
|
#### C. Vote quadratique
|
|
|
|
**Objectif:** Réduire l'influence des gros détenteurs
|
|
|
|
```
|
|
Pouvoir de vote = √(tokens détenus)
|
|
|
|
Exemples:
|
|
- 1 token → 1 vote (√1 = 1)
|
|
- 100 tokens → 10 votes (√100 = 10)
|
|
- 10,000 tokens → 100 votes (√10,000 = 100)
|
|
```
|
|
|
|
**Implémentation:**
|
|
|
|
```rust
|
|
pub struct QuadraticVoting {
|
|
balances: HashMap<OutPoint, u64>,
|
|
}
|
|
|
|
impl QuadraticVoting {
|
|
pub fn vote_power(&self, member_id: &OutPoint) -> u64 {
|
|
let tokens = self.balances.get(member_id).unwrap_or(&0);
|
|
(*tokens as f64).sqrt() as u64
|
|
}
|
|
|
|
pub fn total_vote_power(&self) -> u64 {
|
|
self.balances.values()
|
|
.map(|&tokens| (tokens as f64).sqrt() as u64)
|
|
.sum()
|
|
}
|
|
}
|
|
```
|
|
|
|
**Avantages:**
|
|
|
|
- ✅ Réduit la concentration du pouvoir
|
|
- ✅ Encourage la participation des petits membres
|
|
- ✅ Coût d'attaque plus élevé (quadratique vs linéaire)
|
|
|
|
**Inconvénients:**
|
|
|
|
- ⚠️ Complexité accrue
|
|
- ⚠️ Potentiel de Sybil attacks (multiple comptes)
|
|
|
|
### 2.2 Structure d'une proposition
|
|
|
|
```rust
|
|
pub struct Proposal {
|
|
// Identifiant unique (hash de la proposition)
|
|
id: [u8; 32],
|
|
|
|
// Créateur de la proposition
|
|
proposer: OutPoint,
|
|
|
|
// Titre et description
|
|
title: String,
|
|
description: String,
|
|
|
|
// Type de proposition
|
|
proposal_type: ProposalType,
|
|
|
|
// Actions à exécuter si approuvée
|
|
actions: Vec<ProposalAction>,
|
|
|
|
// Période de vote
|
|
voting_start: u32, // Hauteur de bloc
|
|
voting_end: u32,
|
|
|
|
// État du vote
|
|
votes: HashMap<OutPoint, Vote>,
|
|
|
|
// Statut
|
|
status: ProposalStatus,
|
|
|
|
// Exécution (si approuvée)
|
|
execution: Option<ProposalExecution>,
|
|
}
|
|
|
|
pub enum ProposalType {
|
|
// Modification de paramètres
|
|
ConfigChange(ConfigChange),
|
|
|
|
// Dépense de trésorerie
|
|
TreasurySpend(TreasurySpend),
|
|
|
|
// Ajout/Retrait de membre
|
|
MembershipChange(MembershipChange),
|
|
|
|
// Mise à jour des rôles
|
|
RoleUpdate(RoleUpdate),
|
|
|
|
// Proposition générique
|
|
Generic(String),
|
|
}
|
|
|
|
pub enum Vote {
|
|
Yes,
|
|
No,
|
|
Abstain,
|
|
}
|
|
|
|
pub enum ProposalStatus {
|
|
Draft, // En rédaction
|
|
Active, // Vote en cours
|
|
Passed, // Approuvée
|
|
Rejected, // Rejetée
|
|
Executed, // Exécutée
|
|
Cancelled, // Annulée
|
|
Expired, // Expirée
|
|
}
|
|
```
|
|
|
|
### 2.3 Cycle de vie d'une proposition
|
|
|
|
```
|
|
┌─────────────────┐
|
|
│ 1. CRÉATION │ Membre soumet une proposition
|
|
│ (Draft) │ ├─ Validation formelle
|
|
│ │ └─ Dépôt de caution (optionnel)
|
|
└────────┬────────┘
|
|
│
|
|
▼ voting_start
|
|
┌─────────────────┐
|
|
│ 2. VOTE ACTIF │ Période de vote ouverte
|
|
│ (Active) │ ├─ Membres votent (Yes/No/Abstain)
|
|
│ │ └─ Accumulation des votes
|
|
└────────┬────────┘
|
|
│
|
|
▼ voting_end
|
|
┌─────────────────────────┐
|
|
│ 3. DÉCOMPTE │
|
|
│ ├─ Calcul du quorum │
|
|
│ ├─ Calcul de la majorité│
|
|
│ └─ Détermination statut│
|
|
└────────┬────────────────┘
|
|
│
|
|
┌────┴────┐
|
|
│ │
|
|
▼ ▼
|
|
Passed Rejected
|
|
│
|
|
▼ execution_delay
|
|
┌─────────────────┐
|
|
│ 4. EXÉCUTION │ Création transaction Bitcoin
|
|
│ (Executed) │ ├─ Validation finale
|
|
│ │ ├─ Broadcast transaction
|
|
│ │ └─ Confirmation on-chain
|
|
└─────────────────┘
|
|
```
|
|
|
|
### 2.4 Règles de validation de proposition
|
|
|
|
**Utilisation des ValidationRules de 4NK:**
|
|
|
|
```rust
|
|
// Rôle "proposer" : Peut créer des propositions
|
|
let proposer_role = RoleDefinition {
|
|
members: vec![/* tous les membres */],
|
|
validation_rules: vec![
|
|
ValidationRule::new(
|
|
0.01, // 1% pour créer une proposition (anti-spam)
|
|
vec!["proposals".to_string()],
|
|
0.5, // 50% des devices du membre
|
|
)?,
|
|
],
|
|
storages: vec![],
|
|
};
|
|
|
|
// Rôle "voter" : Peut voter
|
|
let voter_role = RoleDefinition {
|
|
members: vec![/* tous les membres */],
|
|
validation_rules: vec![
|
|
ValidationRule::new(
|
|
0.0, // Pas de quorum (lecture seule)
|
|
vec!["votes".to_string()],
|
|
0.5, // 50% des devices
|
|
)?,
|
|
],
|
|
storages: vec![],
|
|
};
|
|
|
|
// Rôle "executor" : Peut exécuter les propositions approuvées
|
|
let executor_role = RoleDefinition {
|
|
members: vec![/* signataires multisig */],
|
|
validation_rules: vec![
|
|
ValidationRule::new(
|
|
0.67, // 2/3 des signataires
|
|
vec!["executions".to_string()],
|
|
1.0, // Tous les devices (sécurité max)
|
|
)?,
|
|
],
|
|
storages: vec![],
|
|
};
|
|
```
|
|
|
|
### 2.5 Calcul du quorum et de la majorité
|
|
|
|
```rust
|
|
pub struct VoteResult {
|
|
yes_votes: u64,
|
|
no_votes: u64,
|
|
abstain_votes: u64,
|
|
total_power: u64,
|
|
}
|
|
|
|
impl VoteResult {
|
|
pub fn from_votes(
|
|
votes: &HashMap<OutPoint, Vote>,
|
|
members: &HashMap<OutPoint, MemberInfo>,
|
|
voting_system: &VotingSystem,
|
|
state: &DaoState,
|
|
) -> Self {
|
|
let mut yes_votes = 0;
|
|
let mut no_votes = 0;
|
|
let mut abstain_votes = 0;
|
|
|
|
for (member_id, vote) in votes.iter() {
|
|
if let Some(member) = members.get(member_id) {
|
|
let power = voting_system.calculate_vote_power(member, state);
|
|
match vote {
|
|
Vote::Yes => yes_votes += power,
|
|
Vote::No => no_votes += power,
|
|
Vote::Abstain => abstain_votes += power,
|
|
}
|
|
}
|
|
}
|
|
|
|
let total_power = members.values()
|
|
.map(|m| voting_system.calculate_vote_power(m, state))
|
|
.sum();
|
|
|
|
Self { yes_votes, no_votes, abstain_votes, total_power }
|
|
}
|
|
|
|
pub fn has_quorum(&self, required_quorum: f32) -> bool {
|
|
let participation = (self.yes_votes + self.no_votes + self.abstain_votes) as f32
|
|
/ self.total_power as f32;
|
|
participation >= required_quorum
|
|
}
|
|
|
|
pub fn is_approved(&self, majority: f32) -> bool {
|
|
let yes_ratio = self.yes_votes as f32 / (self.yes_votes + self.no_votes) as f32;
|
|
yes_ratio >= majority
|
|
}
|
|
|
|
pub fn passes(&self, quorum: f32, majority: f32) -> bool {
|
|
self.has_quorum(quorum) && self.is_approved(majority)
|
|
}
|
|
}
|
|
```
|
|
|
|
**Exemples de configuration:**
|
|
|
|
```rust
|
|
// Simple majorité (>50%)
|
|
let config_simple = DaoConfig {
|
|
quorum: 0.2, // 20% de participation minimum
|
|
majority: 0.51, // 51% de oui requis
|
|
..Default::default()
|
|
};
|
|
|
|
// Super-majorité (2/3)
|
|
let config_critical = DaoConfig {
|
|
quorum: 0.4, // 40% de participation
|
|
majority: 0.67, // 67% de oui requis
|
|
..Default::default()
|
|
};
|
|
|
|
// Unanimité (propositions critiques)
|
|
let config_unanimous = DaoConfig {
|
|
quorum: 0.9, // 90% de participation
|
|
majority: 1.0, // 100% de oui requis
|
|
..Default::default()
|
|
};
|
|
```
|
|
|
|
---
|
|
|
|
## 3. Système de vote on-chain
|
|
|
|
### 3.1 Enregistrement d'un vote
|
|
|
|
**Flux cryptographique:**
|
|
|
|
```rust
|
|
pub fn cast_vote(
|
|
dao: &DaoProcess,
|
|
proposal_id: [u8; 32],
|
|
vote: Vote,
|
|
member: &Device,
|
|
) -> Result<ProcessState> {
|
|
// 1. Vérifier l'éligibilité
|
|
let member_info = dao.current_state.members
|
|
.get(&member.get_pairing_commitment().unwrap())
|
|
.ok_or("Not a DAO member")?;
|
|
|
|
// 2. Vérifier la période de vote
|
|
let proposal = dao.get_proposal(&proposal_id)?;
|
|
let current_block = get_current_block_height()?;
|
|
if current_block < proposal.voting_start || current_block > proposal.voting_end {
|
|
return Err(anyhow!("Voting period not active"));
|
|
}
|
|
|
|
// 3. Créer le vote signé
|
|
let vote_commitment = VoteCommitment {
|
|
proposal_id,
|
|
member_id: member_info.member_id,
|
|
vote: vote.clone(),
|
|
timestamp: current_block,
|
|
};
|
|
|
|
// 4. Construire le nouvel état
|
|
let mut new_state = dao.process.get_latest_committed_state().unwrap().clone();
|
|
|
|
// Mise à jour du vote dans public_data
|
|
let mut votes_json = new_state.public_data.get_as_json("votes")?;
|
|
let votes_map = votes_json.as_object_mut().unwrap();
|
|
votes_map.insert(
|
|
hex::encode(member_info.member_id.txid.as_byte_array()),
|
|
serde_json::to_value(&vote)?,
|
|
);
|
|
|
|
new_state.public_data.insert_serializable(
|
|
"votes".to_string(),
|
|
&votes_json,
|
|
)?;
|
|
|
|
// 5. Recalculer les commitments
|
|
new_state.pcd_commitment = PcdCommitments::new(
|
|
&new_state.commited_in,
|
|
&Pcd::new(BTreeMap::new()), // Pas de données privées
|
|
&new_state.roles,
|
|
)?;
|
|
|
|
// 6. Calculer le nouveau state_id
|
|
let merkle_tree = new_state.pcd_commitment.create_merkle_tree()?;
|
|
new_state.state_id = merkle_tree.root().unwrap();
|
|
|
|
// 7. Signer avec la clé du membre
|
|
let spend_key: SecretKey = member.get_sp_client().get_spend_key().try_into()?;
|
|
let message_hash = new_state.get_message_hash(true)?;
|
|
let proof = Proof::new(message_hash, spend_key);
|
|
new_state.validation_tokens.push(proof);
|
|
|
|
Ok(new_state)
|
|
}
|
|
```
|
|
|
|
### 3.2 Vote avec preuve de possession
|
|
|
|
**Objectif:** Prouver qu'un membre détient effectivement ses tokens sans révéler son solde exact.
|
|
|
|
```rust
|
|
pub struct VoteWithProof {
|
|
// Vote
|
|
vote: Vote,
|
|
|
|
// Preuve de possession (Merkle proof)
|
|
token_proof: TokenOwnershipProof,
|
|
|
|
// Signature
|
|
signature: Proof,
|
|
}
|
|
|
|
pub struct TokenOwnershipProof {
|
|
// UTXO prouvé
|
|
outpoint: OutPoint,
|
|
|
|
// Chemin Merkle dans l'arbre des tokens
|
|
merkle_path: Vec<[u8; 32]>,
|
|
|
|
// Index dans l'arbre
|
|
leaf_index: usize,
|
|
|
|
// Montant (optionnel, peut être masqué)
|
|
amount: Option<Amount>,
|
|
}
|
|
|
|
impl TokenOwnershipProof {
|
|
pub fn verify(&self, merkle_root: [u8; 32]) -> Result<()> {
|
|
// 1. Reconstruire la feuille
|
|
let leaf = if let Some(amount) = self.amount {
|
|
// Preuve complète
|
|
hash_leaf(&self.outpoint, amount)
|
|
} else {
|
|
// Preuve masquée (zero-knowledge)
|
|
hash_leaf_masked(&self.outpoint)
|
|
};
|
|
|
|
// 2. Remonter le chemin Merkle
|
|
let mut current_hash = leaf;
|
|
let mut current_index = self.leaf_index;
|
|
|
|
for sibling in &self.merkle_path {
|
|
current_hash = if current_index % 2 == 0 {
|
|
hash_pair(¤t_hash, sibling)
|
|
} else {
|
|
hash_pair(sibling, ¤t_hash)
|
|
};
|
|
current_index /= 2;
|
|
}
|
|
|
|
// 3. Vérifier la racine
|
|
if current_hash == merkle_root {
|
|
Ok(())
|
|
} else {
|
|
Err(anyhow!("Invalid Merkle proof"))
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
### 3.3 Vote confidentiel (Optionnel)
|
|
|
|
**Schéma:** Vote chiffré jusqu'à la fin de la période
|
|
|
|
```rust
|
|
pub struct ConfidentialVote {
|
|
// Vote chiffré
|
|
encrypted_vote: Vec<u8>,
|
|
|
|
// Preuve zero-knowledge que le vote est valide
|
|
validity_proof: ValidityProof,
|
|
|
|
// Clé de déchiffrement (révélée après voting_end)
|
|
decryption_key_commitment: [u8; 32],
|
|
}
|
|
|
|
impl ConfidentialVote {
|
|
pub fn new(vote: Vote, public_key: &PublicKey) -> Result<Self> {
|
|
// 1. Chiffrer le vote
|
|
let vote_bytes = bincode::serialize(&vote)?;
|
|
let (ciphertext, nonce, secret) = encrypt_vote(&vote_bytes, public_key)?;
|
|
|
|
// 2. Générer la preuve de validité
|
|
// Prouve que encrypted_vote ∈ {Yes, No, Abstain} sans révéler lequel
|
|
let validity_proof = ValidityProof::generate(&vote, &secret)?;
|
|
|
|
// 3. Commitment de la clé de déchiffrement
|
|
let key_commitment = sha256(&secret);
|
|
|
|
Ok(Self {
|
|
encrypted_vote: ciphertext,
|
|
validity_proof,
|
|
decryption_key_commitment: key_commitment,
|
|
})
|
|
}
|
|
|
|
pub fn reveal(&self, decryption_key: &[u8]) -> Result<Vote> {
|
|
// 1. Vérifier le commitment
|
|
if sha256(decryption_key) != self.decryption_key_commitment {
|
|
return Err(anyhow!("Invalid decryption key"));
|
|
}
|
|
|
|
// 2. Déchiffrer
|
|
let plaintext = decrypt_vote(&self.encrypted_vote, decryption_key)?;
|
|
Ok(bincode::deserialize(&plaintext)?)
|
|
}
|
|
}
|
|
```
|
|
|
|
**Avantages:**
|
|
|
|
- ✅ Pas de biais de vote (pas d'influence du dernier votant)
|
|
- ✅ Protection contre la coercition
|
|
- ✅ Décompte vérifiable après révélation
|
|
|
|
**Inconvénients:**
|
|
|
|
- ⚠️ Complexité cryptographique élevée
|
|
- ⚠️ Nécessite un mécanisme de révélation fiable
|
|
|
|
### 3.4 Commit on-chain du résultat
|
|
|
|
Une fois le vote terminé et le résultat calculé, l'état est committé sur Bitcoin:
|
|
|
|
```rust
|
|
pub fn finalize_proposal(
|
|
dao: &mut DaoProcess,
|
|
proposal_id: [u8; 32],
|
|
) -> Result<Transaction> {
|
|
// 1. Calculer le résultat
|
|
let proposal = dao.get_proposal(&proposal_id)?;
|
|
let result = VoteResult::from_votes(
|
|
&proposal.votes,
|
|
&dao.current_state.members,
|
|
&dao.config.voting_system,
|
|
&dao.current_state,
|
|
);
|
|
|
|
// 2. Déterminer le statut
|
|
let passed = result.passes(dao.config.quorum, 0.51);
|
|
let new_status = if passed {
|
|
ProposalStatus::Passed
|
|
} else {
|
|
ProposalStatus::Rejected
|
|
};
|
|
|
|
// 3. Construire le nouvel état
|
|
let mut new_state = dao.process.get_latest_committed_state().unwrap().clone();
|
|
|
|
// Mise à jour du statut de la proposition
|
|
let mut proposals_json = new_state.public_data.get_as_json("proposals")?;
|
|
let proposals_array = proposals_json.as_array_mut().unwrap();
|
|
|
|
for prop in proposals_array.iter_mut() {
|
|
if prop["id"].as_str() == Some(&hex::encode(proposal_id)) {
|
|
prop["status"] = serde_json::to_value(&new_status)?;
|
|
prop["result"] = serde_json::to_value(&result)?;
|
|
break;
|
|
}
|
|
}
|
|
|
|
new_state.public_data.insert_serializable(
|
|
"proposals".to_string(),
|
|
&proposals_json,
|
|
)?;
|
|
|
|
// 4. Recalculer state_id
|
|
new_state.pcd_commitment = PcdCommitments::new(
|
|
&new_state.commited_in,
|
|
&Pcd::new(BTreeMap::new()),
|
|
&new_state.roles,
|
|
)?;
|
|
let merkle_tree = new_state.pcd_commitment.create_merkle_tree()?;
|
|
new_state.state_id = merkle_tree.root().unwrap();
|
|
|
|
// 5. Collecter les signatures (rôle "executor")
|
|
// ... (processus de validation multi-signatures)
|
|
|
|
// 6. Créer la transaction Bitcoin
|
|
let tx = create_commit_transaction(&dao.process, &new_state)?;
|
|
|
|
Ok(tx)
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 4. Gestion de trésorerie
|
|
|
|
### 4.1 Architecture de trésorerie multisig
|
|
|
|
La trésorerie d'une DAO 4NK utilise un **processus distinct** avec validation multisig:
|
|
|
|
```rust
|
|
pub struct TreasuryProcess {
|
|
// Processus 4NK dédié
|
|
process: Process,
|
|
|
|
// Configuration multisig
|
|
multisig_config: MultisigConfig,
|
|
|
|
// UTXO pool
|
|
utxos: HashMap<OutPoint, TreasuryUtxo>,
|
|
|
|
// Dépenses en attente
|
|
pending_spends: Vec<TreasurySpend>,
|
|
}
|
|
|
|
pub struct MultisigConfig {
|
|
// M-of-N signature scheme
|
|
required_signatures: usize, // M
|
|
total_signers: usize, // N
|
|
|
|
// Signataires (process IDs)
|
|
signers: Vec<OutPoint>,
|
|
|
|
// Adresse de réception (Silent Payment)
|
|
receive_address: SilentPaymentAddress,
|
|
}
|
|
|
|
pub struct TreasuryUtxo {
|
|
outpoint: OutPoint,
|
|
amount: Amount,
|
|
script_pubkey: ScriptBuf,
|
|
confirmed: bool,
|
|
reserved: bool, // Réservé pour une dépense
|
|
}
|
|
```
|
|
|
|
### 4.2 Scripts multisig sur Bitcoin
|
|
|
|
**Option 1: Taproot multisig (recommandé)**
|
|
|
|
```rust
|
|
use bitcoin::taproot::{TaprootBuilder, TaprootSpendInfo};
|
|
use bitcoin::secp256k1::XOnlyPublicKey;
|
|
|
|
pub fn create_taproot_multisig(
|
|
signers: &[XOnlyPublicKey],
|
|
threshold: usize,
|
|
) -> Result<TaprootSpendInfo> {
|
|
// 1. Créer l'arbre Taproot
|
|
let mut builder = TaprootBuilder::new();
|
|
|
|
// 2. Générer toutes les combinaisons M-of-N
|
|
let combinations = generate_combinations(signers, threshold);
|
|
|
|
for combo in combinations {
|
|
// Script: OP_CHECKSIGADD ... OP_GREATERTHAN
|
|
let script = create_musig_script(&combo, threshold)?;
|
|
builder = builder.add_leaf(0, script)?;
|
|
}
|
|
|
|
// 3. Finaliser l'arbre
|
|
let spend_info = builder.finalize(
|
|
&Secp256k1::new(),
|
|
signers[0], // Key path (optionnel)
|
|
)?;
|
|
|
|
Ok(spend_info)
|
|
}
|
|
|
|
fn create_musig_script(keys: &[XOnlyPublicKey], threshold: usize) -> Result<ScriptBuf> {
|
|
let mut script = ScriptBuf::new();
|
|
|
|
// Empiler les clés et vérifier les signatures
|
|
for key in keys {
|
|
script.push_slice(key.serialize());
|
|
script.push_opcode(opcodes::all::OP_CHECKSIG);
|
|
script.push_opcode(opcodes::all::OP_CHECKSIGADD);
|
|
}
|
|
|
|
// Vérifier le seuil
|
|
script.push_int(threshold as i64);
|
|
script.push_opcode(opcodes::all::OP_GREATERTHANOREQUAL);
|
|
|
|
Ok(script)
|
|
}
|
|
```
|
|
|
|
**Option 2: MuSig2 (plus efficace)**
|
|
|
|
```rust
|
|
use secp256k1::musig2::{PartialSignature, AggregateSignature};
|
|
|
|
pub struct MusigTreasury {
|
|
// Clé publique agrégée
|
|
aggregate_pubkey: XOnlyPublicKey,
|
|
|
|
// Participants
|
|
participants: Vec<OutPoint>,
|
|
|
|
// Session de signature en cours
|
|
signing_session: Option<MusigSession>,
|
|
}
|
|
|
|
impl MusigTreasury {
|
|
pub fn new(signers: &[XOnlyPublicKey]) -> Result<Self> {
|
|
// Agréger les clés publiques
|
|
let aggregate_pubkey = aggregate_public_keys(signers)?;
|
|
|
|
Ok(Self {
|
|
aggregate_pubkey,
|
|
participants: vec![],
|
|
signing_session: None,
|
|
})
|
|
}
|
|
|
|
pub fn initiate_spend(
|
|
&mut self,
|
|
spend: &TreasurySpend,
|
|
) -> Result<MusigSession> {
|
|
// 1. Créer la transaction à signer
|
|
let tx = self.create_spend_tx(spend)?;
|
|
|
|
// 2. Initialiser la session MuSig2
|
|
let session = MusigSession::new(
|
|
&self.aggregate_pubkey,
|
|
&tx.txid(),
|
|
&self.participants,
|
|
)?;
|
|
|
|
self.signing_session = Some(session.clone());
|
|
Ok(session)
|
|
}
|
|
|
|
pub fn add_partial_signature(
|
|
&mut self,
|
|
signer: OutPoint,
|
|
partial_sig: PartialSignature,
|
|
) -> Result<Option<AggregateSignature>> {
|
|
let session = self.signing_session.as_mut()
|
|
.ok_or(anyhow!("No active signing session"))?;
|
|
|
|
// Ajouter la signature partielle
|
|
session.add_signature(signer, partial_sig)?;
|
|
|
|
// Vérifier si on a assez de signatures
|
|
if session.has_threshold() {
|
|
let aggregate = session.aggregate()?;
|
|
Ok(Some(aggregate))
|
|
} else {
|
|
Ok(None)
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
**Avantages MuSig2:**
|
|
|
|
- ✅ **Efficacité** : 1 signature agrégée (64 bytes) vs M signatures
|
|
- ✅ **Confidentialité** : Indistinguable d'une signature simple
|
|
- ✅ **Coût** : Frais de transaction réduits
|
|
|
|
### 4.3 Processus de dépense
|
|
|
|
```
|
|
┌──────────────────────────────────────────────────────────┐
|
|
│ ÉTAPE 1: PROPOSITION DE DÉPENSE │
|
|
├──────────────────────────────────────────────────────────┤
|
|
│ │
|
|
│ Membre crée une proposition: │
|
|
│ ├─ Bénéficiaire: sp1qqxxx... │
|
|
│ ├─ Montant: 1.5 BTC │
|
|
│ ├─ Description: "Paiement développeur Q4" │
|
|
│ └─ UTXOs sources: [utxo1, utxo2] │
|
|
│ │
|
|
│ → Vote DAO (processus gouvernance) │
|
|
└──────────────────────────────────────────────────────────┘
|
|
│
|
|
▼ Approuvée
|
|
┌──────────────────────────────────────────────────────────┐
|
|
│ ÉTAPE 2: CONSTRUCTION TRANSACTION │
|
|
├──────────────────────────────────────────────────────────┤
|
|
│ │
|
|
│ Transaction Bitcoin: │
|
|
│ Inputs: [utxo1, utxo2] (trésorerie) │
|
|
│ Outputs: │
|
|
│ - Bénéficiaire: 1.5 BTC │
|
|
│ - Change (trésorerie): 0.49 BTC │
|
|
│ - Frais: 0.01 BTC │
|
|
│ │
|
|
│ Script multisig (Taproot ou MuSig2) │
|
|
└──────────────────────────────────────────────────────────┘
|
|
│
|
|
▼
|
|
┌──────────────────────────────────────────────────────────┐
|
|
│ ÉTAPE 3: COLLECTE DES SIGNATURES │
|
|
├──────────────────────────────────────────────────────────┤
|
|
│ │
|
|
│ Signataires 1, 2, ..., M signent: │
|
|
│ ├─ Signature avec spend_key │
|
|
│ ├─ Envoi via WebSocket (sdk_relay) │
|
|
│ └─ Accumulation dans processus trésorerie │
|
|
│ │
|
|
│ Quorum atteint: M-of-N signatures │
|
|
└──────────────────────────────────────────────────────────┘
|
|
│
|
|
▼
|
|
┌──────────────────────────────────────────────────────────┐
|
|
│ ÉTAPE 4: FINALISATION ET BROADCAST │
|
|
├──────────────────────────────────────────────────────────┤
|
|
│ │
|
|
│ ├─ Agrégation signatures (MuSig2) ou script complet │
|
|
│ ├─ Broadcast sur réseau Bitcoin │
|
|
│ ├─ Attente confirmation (1-6 blocs) │
|
|
│ └─ Mise à jour état trésorerie (UTXO dépensé) │
|
|
│ │
|
|
│ Enregistrement on-chain (OP_RETURN): │
|
|
│ État trésorerie + référence proposition │
|
|
└──────────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
### 4.4 Implémentation de dépense
|
|
|
|
```rust
|
|
pub async fn execute_treasury_spend(
|
|
treasury: &mut TreasuryProcess,
|
|
spend: &TreasurySpend,
|
|
signers: &[Device],
|
|
) -> Result<Txid> {
|
|
// 1. Vérifier que la proposition est approuvée
|
|
if spend.proposal_status != ProposalStatus::Passed {
|
|
return Err(anyhow!("Proposal not approved"));
|
|
}
|
|
|
|
// 2. Sélectionner les UTXOs
|
|
let selected_utxos = treasury.select_utxos(spend.amount)?;
|
|
let total_input = selected_utxos.iter()
|
|
.map(|u| u.amount)
|
|
.sum::<Amount>();
|
|
|
|
// 3. Calculer le change
|
|
let fee = estimate_fee(&selected_utxos, 2)?; // 2 outputs
|
|
let change = total_input - spend.amount - fee;
|
|
|
|
// 4. Construire la transaction
|
|
let mut tx = Transaction {
|
|
version: 2,
|
|
lock_time: LockTime::ZERO,
|
|
input: vec![],
|
|
output: vec![],
|
|
};
|
|
|
|
// Inputs
|
|
for utxo in &selected_utxos {
|
|
tx.input.push(TxIn {
|
|
previous_output: utxo.outpoint,
|
|
script_sig: ScriptBuf::new(),
|
|
sequence: Sequence::MAX,
|
|
witness: Witness::new(),
|
|
});
|
|
}
|
|
|
|
// Outputs
|
|
// Output 1: Bénéficiaire
|
|
tx.output.push(TxOut {
|
|
value: spend.amount,
|
|
script_pubkey: spend.recipient.to_script_pubkey()?,
|
|
});
|
|
|
|
// Output 2: Change (retour à la trésorerie)
|
|
if change > Amount::ZERO {
|
|
tx.output.push(TxOut {
|
|
value: change,
|
|
script_pubkey: treasury.multisig_config.receive_address.to_script_pubkey()?,
|
|
});
|
|
}
|
|
|
|
// 5. Signer avec multisig
|
|
let mut partial_sigs = vec![];
|
|
for (i, signer) in signers.iter().enumerate() {
|
|
let sighash = compute_sighash(&tx, i)?;
|
|
let spend_key: SecretKey = signer.get_sp_client().get_spend_key().try_into()?;
|
|
let sig = sign_sighash(&sighash, &spend_key)?;
|
|
partial_sigs.push(sig);
|
|
}
|
|
|
|
// 6. Finaliser les témoins (witness)
|
|
if treasury.multisig_config.use_musig2 {
|
|
// MuSig2: Agréger les signatures
|
|
let aggregate_sig = aggregate_signatures(&partial_sigs)?;
|
|
for input in &mut tx.input {
|
|
input.witness.push(aggregate_sig.serialize());
|
|
}
|
|
} else {
|
|
// Script multisig traditionnel
|
|
for (i, input) in tx.input.iter_mut().enumerate() {
|
|
let script_witness = build_multisig_witness(&partial_sigs, i)?;
|
|
input.witness = script_witness;
|
|
}
|
|
}
|
|
|
|
// 7. Broadcast
|
|
let txid = broadcast_transaction(&tx).await?;
|
|
|
|
// 8. Mettre à jour l'état de la trésorerie
|
|
treasury.record_spend(txid, spend)?;
|
|
|
|
Ok(txid)
|
|
}
|
|
```
|
|
|
|
### 4.5 Audit de trésorerie
|
|
|
|
**Transparency on-chain:**
|
|
|
|
```rust
|
|
pub struct TreasuryAudit {
|
|
// Snapshot de la trésorerie
|
|
snapshot_time: u32, // Hauteur de bloc
|
|
|
|
// Balance totale
|
|
total_balance: Amount,
|
|
|
|
// UTXOs détaillés
|
|
utxos: Vec<UtxoAudit>,
|
|
|
|
// Historique des dépenses
|
|
spending_history: Vec<SpendAudit>,
|
|
}
|
|
|
|
pub struct UtxoAudit {
|
|
outpoint: OutPoint,
|
|
amount: Amount,
|
|
received_at: u32, // Hauteur de bloc
|
|
script_type: String, // "P2TR", "P2WSH", etc.
|
|
confirmations: u32,
|
|
}
|
|
|
|
pub struct SpendAudit {
|
|
txid: Txid,
|
|
proposal_id: [u8; 32],
|
|
amount: Amount,
|
|
recipient: String,
|
|
executed_at: u32, // Hauteur de bloc
|
|
signers: Vec<OutPoint>, // Qui a signé
|
|
}
|
|
|
|
impl TreasuryProcess {
|
|
pub fn generate_audit_report(&self, block_height: u32) -> Result<TreasuryAudit> {
|
|
let mut utxos_audit = vec![];
|
|
let mut total = Amount::ZERO;
|
|
|
|
for (outpoint, utxo) in &self.utxos {
|
|
if !utxo.reserved {
|
|
total += utxo.amount;
|
|
utxos_audit.push(UtxoAudit {
|
|
outpoint: *outpoint,
|
|
amount: utxo.amount,
|
|
received_at: 0, // À récupérer depuis blockchain
|
|
script_type: "P2TR".to_string(),
|
|
confirmations: block_height - utxo.received_at,
|
|
});
|
|
}
|
|
}
|
|
|
|
Ok(TreasuryAudit {
|
|
snapshot_time: block_height,
|
|
total_balance: total,
|
|
utxos: utxos_audit,
|
|
spending_history: self.get_spending_history()?,
|
|
})
|
|
}
|
|
|
|
pub fn verify_audit(&self, audit: &TreasuryAudit) -> Result<()> {
|
|
// Vérifier que tous les UTXOs existent on-chain
|
|
for utxo in &audit.utxos {
|
|
verify_utxo_exists(&utxo.outpoint)?;
|
|
}
|
|
|
|
// Vérifier que la somme est correcte
|
|
let calculated_total: Amount = audit.utxos.iter()
|
|
.map(|u| u.amount)
|
|
.sum();
|
|
|
|
if calculated_total != audit.total_balance {
|
|
return Err(anyhow!("Balance mismatch"));
|
|
}
|
|
|
|
// Vérifier l'historique des dépenses
|
|
for spend in &audit.spending_history {
|
|
verify_spend_on_chain(&spend.txid)?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 5. Propositions et exécution
|
|
|
|
### 5.1 Types d'actions exécutables
|
|
|
|
```rust
|
|
pub enum ProposalAction {
|
|
// Modification de paramètre
|
|
UpdateConfig {
|
|
parameter: String,
|
|
old_value: Value,
|
|
new_value: Value,
|
|
},
|
|
|
|
// Dépense de trésorerie
|
|
TreasuryTransfer {
|
|
recipient: SilentPaymentAddress,
|
|
amount: Amount,
|
|
description: String,
|
|
},
|
|
|
|
// Ajout/Retrait de membre
|
|
ModifyMembership {
|
|
member_id: OutPoint,
|
|
action: MembershipAction,
|
|
},
|
|
|
|
// Modification des rôles
|
|
UpdateRole {
|
|
role_name: String,
|
|
new_definition: RoleDefinition,
|
|
},
|
|
|
|
// Mise à jour du contrat de la DAO
|
|
UpdateContract {
|
|
contract_hash: [u8; 32],
|
|
contract_url: String,
|
|
},
|
|
|
|
// Appel à un autre processus
|
|
CrossProcessCall {
|
|
target_process: OutPoint,
|
|
function: String,
|
|
params: Value,
|
|
},
|
|
|
|
// Action personnalisée
|
|
Custom {
|
|
action_type: String,
|
|
payload: Vec<u8>,
|
|
},
|
|
}
|
|
|
|
pub enum MembershipAction {
|
|
Add(MemberInfo),
|
|
Remove,
|
|
UpdateVotingPower(u64),
|
|
UpdateDelegation(Option<OutPoint>),
|
|
}
|
|
```
|
|
|
|
### 5.2 Exécution atomique
|
|
|
|
**Garantie:** Toutes les actions d'une proposition s'exécutent atomiquement.
|
|
|
|
```rust
|
|
pub fn execute_proposal(
|
|
dao: &mut DaoProcess,
|
|
treasury: &mut TreasuryProcess,
|
|
proposal: &Proposal,
|
|
) -> Result<Vec<ExecutionResult>> {
|
|
if proposal.status != ProposalStatus::Passed {
|
|
return Err(anyhow!("Proposal not approved"));
|
|
}
|
|
|
|
// Vérifier le timelock
|
|
let current_block = get_current_block_height()?;
|
|
let execution_block = proposal.voting_end + dao.config.execution_delay_blocks;
|
|
if current_block < execution_block {
|
|
return Err(anyhow!("Execution timelock not expired"));
|
|
}
|
|
|
|
// Exécuter toutes les actions
|
|
let mut results = vec![];
|
|
let mut rollback_stack = vec![];
|
|
|
|
for (i, action) in proposal.actions.iter().enumerate() {
|
|
match execute_action(dao, treasury, action) {
|
|
Ok(result) => {
|
|
results.push(result.clone());
|
|
rollback_stack.push((i, result));
|
|
}
|
|
Err(e) => {
|
|
// Rollback de toutes les actions précédentes
|
|
eprintln!("Action {} failed: {}", i, e);
|
|
for (idx, result) in rollback_stack.iter().rev() {
|
|
rollback_action(dao, treasury, *idx, result)?;
|
|
}
|
|
return Err(anyhow!("Proposal execution failed at action {}: {}", i, e));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Marquer la proposition comme exécutée
|
|
dao.mark_proposal_executed(proposal.id, results.clone())?;
|
|
|
|
Ok(results)
|
|
}
|
|
|
|
fn execute_action(
|
|
dao: &mut DaoProcess,
|
|
treasury: &mut TreasuryProcess,
|
|
action: &ProposalAction,
|
|
) -> Result<ExecutionResult> {
|
|
match action {
|
|
ProposalAction::UpdateConfig { parameter, new_value, .. } => {
|
|
dao.update_config(parameter, new_value)?;
|
|
Ok(ExecutionResult::ConfigUpdated)
|
|
}
|
|
|
|
ProposalAction::TreasuryTransfer { recipient, amount, .. } => {
|
|
let spend = TreasurySpend {
|
|
recipient: recipient.clone(),
|
|
amount: *amount,
|
|
proposal_id: dao.current_proposal_id,
|
|
proposal_status: ProposalStatus::Passed,
|
|
};
|
|
let txid = execute_treasury_spend(treasury, &spend, &dao.signers).await?;
|
|
Ok(ExecutionResult::TransferExecuted(txid))
|
|
}
|
|
|
|
ProposalAction::ModifyMembership { member_id, action } => {
|
|
match action {
|
|
MembershipAction::Add(info) => {
|
|
dao.add_member(*member_id, info.clone())?;
|
|
Ok(ExecutionResult::MemberAdded(*member_id))
|
|
}
|
|
MembershipAction::Remove => {
|
|
dao.remove_member(*member_id)?;
|
|
Ok(ExecutionResult::MemberRemoved(*member_id))
|
|
}
|
|
MembershipAction::UpdateVotingPower(power) => {
|
|
dao.update_voting_power(*member_id, *power)?;
|
|
Ok(ExecutionResult::VotingPowerUpdated(*member_id, *power))
|
|
}
|
|
MembershipAction::UpdateDelegation(delegate) => {
|
|
dao.update_delegation(*member_id, *delegate)?;
|
|
Ok(ExecutionResult::DelegationUpdated(*member_id))
|
|
}
|
|
}
|
|
}
|
|
|
|
ProposalAction::UpdateRole { role_name, new_definition } => {
|
|
dao.update_role(role_name, new_definition.clone())?;
|
|
Ok(ExecutionResult::RoleUpdated(role_name.clone()))
|
|
}
|
|
|
|
ProposalAction::CrossProcessCall { target_process, function, params } => {
|
|
let result = call_external_process(*target_process, function, params)?;
|
|
Ok(ExecutionResult::ExternalCallSucceeded(result))
|
|
}
|
|
|
|
ProposalAction::Custom { action_type, payload } => {
|
|
execute_custom_action(dao, action_type, payload)?;
|
|
Ok(ExecutionResult::CustomActionExecuted)
|
|
}
|
|
|
|
_ => Err(anyhow!("Unknown action type")),
|
|
}
|
|
}
|
|
```
|
|
|
|
### 5.3 Timelock et sécurité
|
|
|
|
**Délai d'exécution** : Période entre l'approbation et l'exécution
|
|
|
|
```rust
|
|
pub struct ExecutionTimelock {
|
|
// Délai minimum (en blocs)
|
|
min_delay: u32,
|
|
|
|
// Délai variable selon le type de proposition
|
|
delay_by_type: HashMap<String, u32>,
|
|
|
|
// Délai d'urgence (rôle spécial requis)
|
|
emergency_delay: u32,
|
|
}
|
|
|
|
impl ExecutionTimelock {
|
|
pub fn calculate_delay(&self, proposal: &Proposal) -> u32 {
|
|
// Délai par défaut
|
|
let mut delay = self.min_delay;
|
|
|
|
// Ajuster selon le type
|
|
if let Some(&custom_delay) = self.delay_by_type.get(&proposal.proposal_type.to_string()) {
|
|
delay = delay.max(custom_delay);
|
|
}
|
|
|
|
// Propositions critiques = délai plus long
|
|
if proposal.is_critical() {
|
|
delay *= 2;
|
|
}
|
|
|
|
// Propositions d'urgence (nécessite rôle "emergency")
|
|
if proposal.is_emergency() && self.has_emergency_approval(proposal) {
|
|
delay = self.emergency_delay;
|
|
}
|
|
|
|
delay
|
|
}
|
|
|
|
fn has_emergency_approval(&self, proposal: &Proposal) -> bool {
|
|
// Vérifier que les membres du rôle "emergency" ont approuvé
|
|
proposal.votes.iter()
|
|
.filter(|(member, vote)| {
|
|
self.is_emergency_member(member) && **vote == Vote::Yes
|
|
})
|
|
.count() >= self.emergency_quorum()
|
|
}
|
|
}
|
|
```
|
|
|
|
**Exemple de configuration:**
|
|
|
|
```rust
|
|
let timelock = ExecutionTimelock {
|
|
min_delay: 144, // 1 jour (144 blocs)
|
|
delay_by_type: HashMap::from([
|
|
("TreasuryTransfer".to_string(), 288), // 2 jours
|
|
("UpdateRole".to_string(), 432), // 3 jours
|
|
("UpdateContract".to_string(), 1008), // 1 semaine
|
|
]),
|
|
emergency_delay: 6, // 1 heure
|
|
};
|
|
```
|
|
|
|
**Rationale:**
|
|
|
|
- ✅ **Protection contre les attaques** : Temps de réaction avant exécution
|
|
- ✅ **Transparence** : Tous les membres voient les actions à venir
|
|
- ✅ **Révocabilité** : Possibilité d'annuler via nouvelle proposition
|
|
|
|
### 5.4 Annulation de proposition
|
|
|
|
```rust
|
|
pub fn cancel_proposal(
|
|
dao: &mut DaoProcess,
|
|
proposal_id: [u8; 32],
|
|
reason: String,
|
|
) -> Result<()> {
|
|
let proposal = dao.get_proposal(&proposal_id)?;
|
|
|
|
// Vérifications
|
|
if proposal.status == ProposalStatus::Executed {
|
|
return Err(anyhow!("Cannot cancel executed proposal"));
|
|
}
|
|
|
|
// Qui peut annuler ?
|
|
// 1. Le proposeur (avant le début du vote)
|
|
// 2. Le rôle "guardian" (à tout moment)
|
|
// 3. Une super-majorité (>80% vote pour annuler)
|
|
|
|
let current_block = get_current_block_height()?;
|
|
let caller = get_caller_member_id()?;
|
|
|
|
let can_cancel =
|
|
// Cas 1: Proposeur avant le vote
|
|
(caller == proposal.proposer && current_block < proposal.voting_start)
|
|
|
|
// Cas 2: Guardian
|
|
|| dao.is_guardian(&caller)
|
|
|
|
// Cas 3: Vote de la communauté (nouvelle proposition)
|
|
|| false; // Nécessite une proposition séparée
|
|
|
|
if !can_cancel {
|
|
return Err(anyhow!("Not authorized to cancel"));
|
|
}
|
|
|
|
// Annuler
|
|
dao.set_proposal_status(proposal_id, ProposalStatus::Cancelled)?;
|
|
|
|
// Enregistrer la raison
|
|
dao.add_cancellation_record(proposal_id, reason)?;
|
|
|
|
Ok(())
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 6. Tokenisation et pondération
|
|
|
|
### 6.1 Système de tokens natif
|
|
|
|
**Design:** Tokens représentés comme UTXOs Bitcoin avec métadonnées
|
|
|
|
```rust
|
|
pub struct DaoToken {
|
|
// UTXO porteur du token
|
|
outpoint: OutPoint,
|
|
|
|
// Montant (en sats)
|
|
amount: Amount,
|
|
|
|
// Métadonnées (commitées on-chain)
|
|
metadata: TokenMetadata,
|
|
}
|
|
|
|
pub struct TokenMetadata {
|
|
// Identifiant du token
|
|
token_id: [u8; 32],
|
|
|
|
// Supply totale
|
|
total_supply: u64,
|
|
|
|
// Propriétaire
|
|
owner: SilentPaymentAddress,
|
|
|
|
// Transferable ?
|
|
transferable: bool,
|
|
|
|
// Vesting (optionnel)
|
|
vesting: Option<VestingSchedule>,
|
|
}
|
|
|
|
pub struct VestingSchedule {
|
|
// Montant initial bloqué
|
|
initial_amount: u64,
|
|
|
|
// Date de début (hauteur de bloc)
|
|
start_block: u32,
|
|
|
|
// Durée (en blocs)
|
|
duration_blocks: u32,
|
|
|
|
// Cliff (période initiale sans unlock)
|
|
cliff_blocks: u32,
|
|
|
|
// Montant déjà débloqué
|
|
unlocked_amount: u64,
|
|
}
|
|
|
|
impl VestingSchedule {
|
|
pub fn available_amount(&self, current_block: u32) -> u64 {
|
|
if current_block < self.start_block + self.cliff_blocks {
|
|
// Cliff period
|
|
return 0;
|
|
}
|
|
|
|
let elapsed = current_block.saturating_sub(self.start_block);
|
|
if elapsed >= self.duration_blocks {
|
|
// Fully vested
|
|
return self.initial_amount;
|
|
}
|
|
|
|
// Linear vesting
|
|
let vested = (self.initial_amount as f64 * elapsed as f64 / self.duration_blocks as f64) as u64;
|
|
vested.saturating_sub(self.unlocked_amount)
|
|
}
|
|
}
|
|
```
|
|
|
|
### 6.2 Distribution initiale
|
|
|
|
**Mécanisme:** Création d'un processus "token_distribution"
|
|
|
|
```rust
|
|
pub fn create_token_distribution(
|
|
dao: &DaoProcess,
|
|
distribution: &TokenDistribution,
|
|
) -> Result<Process> {
|
|
// 1. Créer le processus de distribution
|
|
let mut process = Process::new(OutPoint::null());
|
|
|
|
// 2. Définir la supply totale
|
|
let total_supply = distribution.allocations.values().sum::<u64>();
|
|
|
|
// 3. Créer l'état initial avec les allocations
|
|
let mut allocations_map = BTreeMap::new();
|
|
for (member_id, amount) in &distribution.allocations {
|
|
allocations_map.insert(
|
|
hex::encode(member_id.txid.as_byte_array()),
|
|
json!({
|
|
"amount": amount,
|
|
"vesting": distribution.vesting.clone(),
|
|
}),
|
|
);
|
|
}
|
|
|
|
let public_data = json!({
|
|
"token_id": distribution.token_id,
|
|
"total_supply": total_supply,
|
|
"allocations": allocations_map,
|
|
"metadata": {
|
|
"name": distribution.name,
|
|
"symbol": distribution.symbol,
|
|
"decimals": distribution.decimals,
|
|
}
|
|
});
|
|
|
|
let initial_state = ProcessState::new(
|
|
process.get_process_tip()?,
|
|
Pcd::new(BTreeMap::new()), // Pas de données privées
|
|
public_data.try_into()?,
|
|
distribution.roles.clone(),
|
|
)?;
|
|
|
|
// 4. Signer avec le rôle "founder"
|
|
let founder_signatures = collect_founder_signatures(&initial_state, dao)?;
|
|
initial_state.validation_tokens = founder_signatures;
|
|
|
|
// 5. Insérer l'état
|
|
process.insert_concurrent_state(initial_state)?;
|
|
|
|
Ok(process)
|
|
}
|
|
|
|
pub struct TokenDistribution {
|
|
token_id: [u8; 32],
|
|
name: String,
|
|
symbol: String,
|
|
decimals: u8,
|
|
|
|
// Allocations initiales
|
|
allocations: HashMap<OutPoint, u64>,
|
|
|
|
// Vesting (optionnel)
|
|
vesting: Option<VestingSchedule>,
|
|
|
|
// Rôles de gouvernance du token
|
|
roles: Roles,
|
|
}
|
|
```
|
|
|
|
**Exemple de distribution:**
|
|
|
|
```rust
|
|
let distribution = TokenDistribution {
|
|
token_id: sha256(b"MyDAO_TOKEN"),
|
|
name: "MyDAO Governance Token".to_string(),
|
|
symbol: "MDAO".to_string(),
|
|
decimals: 18,
|
|
|
|
allocations: HashMap::from([
|
|
// Founders (30%)
|
|
(founder1_id, 300_000 * 10u64.pow(18)),
|
|
(founder2_id, 300_000 * 10u64.pow(18)),
|
|
|
|
// Early investors (20%)
|
|
(investor1_id, 200_000 * 10u64.pow(18)),
|
|
|
|
// Community treasury (40%)
|
|
(dao_treasury_id, 400_000 * 10u64.pow(18)),
|
|
|
|
// Team (10%, vested)
|
|
(team_pool_id, 100_000 * 10u64.pow(18)),
|
|
]),
|
|
|
|
vesting: Some(VestingSchedule {
|
|
initial_amount: 100_000 * 10u64.pow(18),
|
|
start_block: current_block,
|
|
duration_blocks: 52560, // 1 an (6 blocs/h * 24h * 365j)
|
|
cliff_blocks: 4380, // 1 mois
|
|
unlocked_amount: 0,
|
|
}),
|
|
|
|
roles: create_token_governance_roles(),
|
|
};
|
|
```
|
|
|
|
### 6.3 Transfert de tokens
|
|
|
|
```rust
|
|
pub fn transfer_tokens(
|
|
from: &Device,
|
|
to: &SilentPaymentAddress,
|
|
amount: u64,
|
|
token_process: &mut Process,
|
|
) -> Result<ProcessState> {
|
|
// 1. Vérifier le solde
|
|
let current_state = token_process.get_latest_committed_state().unwrap();
|
|
let from_id = from.get_pairing_commitment().unwrap();
|
|
|
|
let balances: HashMap<String, u64> = current_state
|
|
.public_data
|
|
.get_as_json("balances")?
|
|
.as_object()
|
|
.unwrap()
|
|
.iter()
|
|
.map(|(k, v)| (k.clone(), v.as_u64().unwrap()))
|
|
.collect();
|
|
|
|
let from_balance = balances.get(&hex::encode(from_id.txid.as_byte_array()))
|
|
.copied()
|
|
.unwrap_or(0);
|
|
|
|
if from_balance < amount {
|
|
return Err(anyhow!("Insufficient balance"));
|
|
}
|
|
|
|
// 2. Créer le nouvel état
|
|
let mut new_balances = balances;
|
|
*new_balances.get_mut(&hex::encode(from_id.txid.as_byte_array())).unwrap() -= amount;
|
|
|
|
let to_key = hex::encode(to.get_scan_public_key().serialize());
|
|
*new_balances.entry(to_key).or_insert(0) += amount;
|
|
|
|
let mut new_state = current_state.clone();
|
|
new_state.public_data.insert_serializable(
|
|
"balances".to_string(),
|
|
&json!(new_balances),
|
|
)?;
|
|
|
|
// 3. Recalculer state_id
|
|
new_state.pcd_commitment = PcdCommitments::new(
|
|
&new_state.commited_in,
|
|
&Pcd::new(BTreeMap::new()),
|
|
&new_state.roles,
|
|
)?;
|
|
let merkle_tree = new_state.pcd_commitment.create_merkle_tree()?;
|
|
new_state.state_id = merkle_tree.root().unwrap();
|
|
|
|
// 4. Signer
|
|
let spend_key: SecretKey = from.get_sp_client().get_spend_key().try_into()?;
|
|
let message_hash = new_state.get_message_hash(true)?;
|
|
let proof = Proof::new(message_hash, spend_key);
|
|
new_state.validation_tokens.push(proof);
|
|
|
|
Ok(new_state)
|
|
}
|
|
```
|
|
|
|
### 6.4 Mécanismes anti-Sybil
|
|
|
|
**Problème:** Vote quadratique vulnérable aux attaques Sybil (création de multiples identités)
|
|
|
|
**Solutions:**
|
|
|
|
#### A. Preuve d'humanité
|
|
|
|
```rust
|
|
pub struct HumanityProof {
|
|
// Preuve cryptographique d'humanité
|
|
proof_type: HumanityProofType,
|
|
|
|
// Données de la preuve
|
|
proof_data: Vec<u8>,
|
|
|
|
// Validité
|
|
valid_until: u32, // Hauteur de bloc
|
|
}
|
|
|
|
pub enum HumanityProofType {
|
|
// Preuve biométrique (empreinte faciale)
|
|
Biometric(BiometricProof),
|
|
|
|
// Preuve sociale (attestations)
|
|
SocialVouching(Vec<Attestation>),
|
|
|
|
// Preuve financière (dépôt important)
|
|
StakeProof(Amount),
|
|
|
|
// Intégration Worldcoin/autres
|
|
ExternalOracle(String),
|
|
}
|
|
|
|
pub struct Attestation {
|
|
// Attestateur
|
|
attester: OutPoint,
|
|
|
|
// Sujet attesté
|
|
subject: OutPoint,
|
|
|
|
// Signature
|
|
signature: Proof,
|
|
|
|
// Validité
|
|
expires_at: u32,
|
|
}
|
|
```
|
|
|
|
#### B. Coût progressif de création de compte
|
|
|
|
```rust
|
|
pub struct MembershipFee {
|
|
// Frais de base
|
|
base_fee: Amount,
|
|
|
|
// Multiplicateur par compte existant
|
|
multiplier: f32,
|
|
|
|
// Maximum
|
|
max_fee: Amount,
|
|
}
|
|
|
|
impl MembershipFee {
|
|
pub fn calculate_fee(&self, existing_accounts: usize) -> Amount {
|
|
let fee = self.base_fee.to_sat() as f32 * self.multiplier.powi(existing_accounts as i32);
|
|
Amount::from_sat((fee as u64).min(self.max_fee.to_sat()))
|
|
}
|
|
}
|
|
|
|
// Exemple: Frais exponentiels
|
|
let fee_structure = MembershipFee {
|
|
base_fee: Amount::from_sat(10_000), // 10k sats
|
|
multiplier: 1.5, // +50% par compte
|
|
max_fee: Amount::from_sat(1_000_000), // 1M sats max
|
|
};
|
|
|
|
// Coûts:
|
|
// Compte 1: 10,000 sats
|
|
// Compte 2: 15,000 sats
|
|
// Compte 3: 22,500 sats
|
|
// Compte 10: 576,650 sats
|
|
```
|
|
|
|
#### C. Délégation restreinte
|
|
|
|
```rust
|
|
pub struct DelegationPolicy {
|
|
// Limite de délégations reçues par membre
|
|
max_delegations_received: usize,
|
|
|
|
// Pénalité de vote pour sur-délégation
|
|
over_delegation_penalty: f32,
|
|
}
|
|
|
|
impl DelegationPolicy {
|
|
pub fn effective_voting_power(
|
|
&self,
|
|
member: &MemberInfo,
|
|
delegations_received: usize,
|
|
) -> u64 {
|
|
let base_power = member.voting_power;
|
|
|
|
if delegations_received <= self.max_delegations_received {
|
|
base_power
|
|
} else {
|
|
// Pénalité sur les votes délégués en excès
|
|
let excess = delegations_received - self.max_delegations_received;
|
|
let penalty = 1.0 - (excess as f32 * self.over_delegation_penalty);
|
|
(base_power as f32 * penalty.max(0.0)) as u64
|
|
}
|
|
}
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## 7. Sécurité et attaques
|
|
|
|
### 7.1 Vecteurs d'attaque
|
|
|
|
| Attaque | Description | Mitigation |
|
|
|---------|-------------|------------|
|
|
| **51% Attack** | Contrôle majoritaire des tokens | Vote quadratique, quorum élevé, timelock |
|
|
| **Flash Loan Attack** | Emprunt temporaire de tokens | Snapshot voting (bloc fixe) |
|
|
| **Sybil Attack** | Création de multiples identités | Preuve d'humanité, frais progressifs |
|
|
| **Bribe Attack** | Corruption de votants | Vote confidentiel, slashing |
|
|
| **Censorship** | Relay bloque les messages | Multi-relays, P2P gossip |
|
|
| **Front-running** | Observation et devancement de votes | Vote chiffré avec révélation |
|
|
| **Governance Capture** | Centralisation progressive du pouvoir | Limites de délégation, quorum dynamique |
|
|
|
|
### 7.2 Flash loan attack mitigation
|
|
|
|
**Problème:** Emprunter massivement des tokens juste pour voter
|
|
|
|
```rust
|
|
pub struct SnapshotVoting {
|
|
// Bloc de snapshot (avant le début du vote)
|
|
snapshot_block: u32,
|
|
|
|
// Balances figées à ce bloc
|
|
snapshot_balances: HashMap<OutPoint, u64>,
|
|
}
|
|
|
|
impl SnapshotVoting {
|
|
pub fn create_snapshot(
|
|
proposal: &Proposal,
|
|
lookback_blocks: u32,
|
|
) -> Result<Self> {
|
|
// Snapshot N blocs avant le début du vote
|
|
let snapshot_block = proposal.voting_start.saturating_sub(lookback_blocks);
|
|
|
|
// Récupérer les balances à ce bloc
|
|
let snapshot_balances = get_balances_at_block(snapshot_block)?;
|
|
|
|
Ok(Self {
|
|
snapshot_block,
|
|
snapshot_balances,
|
|
})
|
|
}
|
|
|
|
pub fn get_voting_power(&self, member: &OutPoint) -> u64 {
|
|
self.snapshot_balances.get(member).copied().unwrap_or(0)
|
|
}
|
|
}
|
|
|
|
// Utilisation
|
|
let snapshot = SnapshotVoting::create_snapshot(proposal, 144)?; // 1 jour avant
|
|
let voting_power = snapshot.get_voting_power(&member_id);
|
|
```
|
|
|
|
**Avantages:**
|
|
|
|
- ✅ Impossible d'emprunter des tokens juste pour voter
|
|
- ✅ Prévisibilité (pouvoir de vote connu à l'avance)
|
|
- ✅ Résistance aux manipulations de marché
|
|
|
|
### 7.3 Slashing pour mauvais comportement
|
|
|
|
```rust
|
|
pub struct SlashingPolicy {
|
|
// Types de fautes
|
|
offenses: HashMap<OffenseType, SlashingRule>,
|
|
}
|
|
|
|
pub enum OffenseType {
|
|
// Vote malveillant (deux fois différemment)
|
|
DoubleVoting,
|
|
|
|
// Proposition spam
|
|
SpamProposal,
|
|
|
|
// Exécution malveillante
|
|
MaliciousExecution,
|
|
|
|
// Violation de règles
|
|
RuleViolation,
|
|
}
|
|
|
|
pub struct SlashingRule {
|
|
// Pénalité (% des tokens)
|
|
slash_percentage: f32,
|
|
|
|
// Montant minimum slashé
|
|
min_slash: Amount,
|
|
|
|
// Destination des tokens slashés
|
|
destination: SlashDestination,
|
|
}
|
|
|
|
pub enum SlashDestination {
|
|
Burn, // Détruire
|
|
Treasury, // Trésorerie DAO
|
|
Reporter(OutPoint), // Celui qui a signalé
|
|
Redistribute, // Redistribuer aux autres membres
|
|
}
|
|
|
|
impl SlashingPolicy {
|
|
pub fn slash_member(
|
|
&self,
|
|
dao: &mut DaoProcess,
|
|
member_id: &OutPoint,
|
|
offense: OffenseType,
|
|
evidence: &Evidence,
|
|
) -> Result<Amount> {
|
|
// 1. Vérifier l'évidence
|
|
if !self.verify_evidence(offense, evidence)? {
|
|
return Err(anyhow!("Invalid evidence"));
|
|
}
|
|
|
|
// 2. Calculer le montant à slasher
|
|
let rule = self.offenses.get(&offense)
|
|
.ok_or(anyhow!("Unknown offense"))?;
|
|
|
|
let member_balance = dao.get_member_balance(member_id)?;
|
|
let slash_amount = (member_balance.to_sat() as f32 * rule.slash_percentage) as u64;
|
|
let slash_amount = slash_amount.max(rule.min_slash.to_sat());
|
|
let slash_amount = Amount::from_sat(slash_amount);
|
|
|
|
// 3. Exécuter le slashing
|
|
dao.reduce_member_balance(member_id, slash_amount)?;
|
|
|
|
// 4. Distribuer selon la règle
|
|
match &rule.destination {
|
|
SlashDestination::Burn => {
|
|
dao.burn_tokens(slash_amount)?;
|
|
}
|
|
SlashDestination::Treasury => {
|
|
dao.transfer_to_treasury(slash_amount)?;
|
|
}
|
|
SlashDestination::Reporter(reporter) => {
|
|
dao.transfer_to_member(reporter, slash_amount)?;
|
|
}
|
|
SlashDestination::Redistribute => {
|
|
dao.redistribute_to_all(slash_amount)?;
|
|
}
|
|
}
|
|
|
|
// 5. Enregistrer l'événement
|
|
dao.record_slashing_event(member_id, offense, slash_amount)?;
|
|
|
|
Ok(slash_amount)
|
|
}
|
|
}
|
|
```
|
|
|
|
### 7.4 Quorum dynamique
|
|
|
|
**Objectif:** Adapter le quorum selon l'activité de la DAO
|
|
|
|
```rust
|
|
pub struct DynamicQuorum {
|
|
// Quorum de base
|
|
base_quorum: f32,
|
|
|
|
// Historique de participation
|
|
participation_history: Vec<f32>,
|
|
|
|
// Fenêtre d'historique
|
|
history_window: usize,
|
|
}
|
|
|
|
impl DynamicQuorum {
|
|
pub fn calculate_quorum(&self) -> f32 {
|
|
if self.participation_history.is_empty() {
|
|
return self.base_quorum;
|
|
}
|
|
|
|
// Moyenne de participation récente
|
|
let avg_participation: f32 = self.participation_history.iter().sum::<f32>()
|
|
/ self.participation_history.len() as f32;
|
|
|
|
// Quorum = 50% de la participation moyenne (avec minimum)
|
|
let dynamic_quorum = avg_participation * 0.5;
|
|
dynamic_quorum.max(self.base_quorum)
|
|
}
|
|
|
|
pub fn update_with_vote(&mut self, participation: f32) {
|
|
self.participation_history.push(participation);
|
|
|
|
// Garder seulement les N derniers votes
|
|
if self.participation_history.len() > self.history_window {
|
|
self.participation_history.remove(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Exemple
|
|
let mut quorum = DynamicQuorum {
|
|
base_quorum: 0.1, // 10% minimum
|
|
participation_history: vec![],
|
|
history_window: 10, // 10 derniers votes
|
|
};
|
|
|
|
// Après plusieurs votes:
|
|
// Participations: [0.3, 0.4, 0.35, 0.5, 0.45, 0.4, 0.38, 0.42, 0.36, 0.41]
|
|
// Moyenne: 0.397
|
|
// Quorum dynamique: 0.397 * 0.5 = 0.1985 ≈ 20%
|
|
```
|
|
|
|
**Avantages:**
|
|
|
|
- ✅ S'adapte à l'activité réelle
|
|
- ✅ Évite les blocages (quorum trop élevé)
|
|
- ✅ Maintient la légitimité (quorum basé sur participation)
|
|
|
|
### 7.5 Rate limiting
|
|
|
|
```rust
|
|
pub struct RateLimiter {
|
|
// Limite de propositions par membre
|
|
max_proposals_per_period: usize,
|
|
|
|
// Période (en blocs)
|
|
period_blocks: u32,
|
|
|
|
// Historique
|
|
proposal_history: HashMap<OutPoint, Vec<u32>>,
|
|
}
|
|
|
|
impl RateLimiter {
|
|
pub fn can_propose(&mut self, member_id: &OutPoint, current_block: u32) -> bool {
|
|
let history = self.proposal_history
|
|
.entry(*member_id)
|
|
.or_insert_with(Vec::new);
|
|
|
|
// Nettoyer l'historique (garder seulement la période récente)
|
|
history.retain(|&block| block > current_block.saturating_sub(self.period_blocks));
|
|
|
|
// Vérifier la limite
|
|
if history.len() >= self.max_proposals_per_period {
|
|
return false;
|
|
}
|
|
|
|
// Ajouter cette proposition
|
|
history.push(current_block);
|
|
true
|
|
}
|
|
}
|
|
|
|
// Exemple: Max 3 propositions par semaine
|
|
let limiter = RateLimiter {
|
|
max_proposals_per_period: 3,
|
|
period_blocks: 1008, // ~1 semaine
|
|
proposal_history: HashMap::new(),
|
|
};
|
|
```
|
|
|
|
---
|
|
|
|
## 8. Implémentation de référence
|
|
|
|
### 8.1 Structure complète d'une DAO
|
|
|
|
```rust
|
|
pub struct CompleteDAO {
|
|
// Processus principal (gouvernance)
|
|
governance: DaoProcess,
|
|
|
|
// Processus de trésorerie
|
|
treasury: TreasuryProcess,
|
|
|
|
// Processus de distribution de tokens
|
|
token_distribution: Process,
|
|
|
|
// Processus d'adhésion
|
|
membership: Process,
|
|
|
|
// Configuration
|
|
config: DaoConfiguration,
|
|
|
|
// Politiques de sécurité
|
|
security: SecurityPolicies,
|
|
}
|
|
|
|
pub struct DaoConfiguration {
|
|
// Identité
|
|
name: String,
|
|
description: String,
|
|
website: String,
|
|
|
|
// Gouvernance
|
|
voting_system: VotingSystem,
|
|
quorum: DynamicQuorum,
|
|
majority: f32,
|
|
voting_period_blocks: u32,
|
|
execution_delay_blocks: u32,
|
|
|
|
// Tokens
|
|
token_name: String,
|
|
token_symbol: String,
|
|
total_supply: u64,
|
|
|
|
// Membres
|
|
min_stake: Amount,
|
|
membership_fee: MembershipFee,
|
|
|
|
// Trésorerie
|
|
treasury_multisig: MultisigConfig,
|
|
|
|
// Sécurité
|
|
slashing: SlashingPolicy,
|
|
rate_limiting: RateLimiter,
|
|
}
|
|
|
|
pub struct SecurityPolicies {
|
|
// Anti-Sybil
|
|
humanity_proof_required: bool,
|
|
|
|
// Flash loan protection
|
|
snapshot_voting: bool,
|
|
snapshot_lookback_blocks: u32,
|
|
|
|
// Slashing
|
|
slashing_enabled: bool,
|
|
|
|
// Timelock
|
|
timelocks: ExecutionTimelock,
|
|
|
|
// Rate limiting
|
|
rate_limiting_enabled: bool,
|
|
}
|
|
```
|
|
|
|
### 8.2 Initialisation d'une DAO
|
|
|
|
```rust
|
|
pub async fn initialize_dao(
|
|
founders: Vec<Device>,
|
|
config: DaoConfiguration,
|
|
) -> Result<CompleteDAO> {
|
|
// 1. Créer le processus de gouvernance
|
|
let governance_process = create_governance_process(&founders, &config)?;
|
|
|
|
// 2. Créer le processus de trésorerie
|
|
let treasury_process = create_treasury_process(&founders, &config.treasury_multisig)?;
|
|
|
|
// 3. Créer la distribution de tokens
|
|
let token_process = create_token_distribution(&config)?;
|
|
|
|
// 4. Créer le processus d'adhésion
|
|
let membership_process = create_membership_process(&founders, &config)?;
|
|
|
|
// 5. Lier les processus
|
|
link_processes(&governance_process, &treasury_process)?;
|
|
link_processes(&governance_process, &token_process)?;
|
|
link_processes(&governance_process, &membership_process)?;
|
|
|
|
// 6. Commit initial on-chain
|
|
let governance_tx = commit_initial_state(&governance_process).await?;
|
|
let treasury_tx = commit_initial_state(&treasury_process).await?;
|
|
let token_tx = commit_initial_state(&token_process).await?;
|
|
let membership_tx = commit_initial_state(&membership_process).await?;
|
|
|
|
// 7. Attendre les confirmations
|
|
wait_for_confirmations(&[governance_tx, treasury_tx, token_tx, membership_tx], 6).await?;
|
|
|
|
// 8. Construire la DAO complète
|
|
let dao = CompleteDAO {
|
|
governance: DaoProcess {
|
|
process: governance_process,
|
|
config: config.clone(),
|
|
current_state: DaoState::default(),
|
|
},
|
|
treasury: treasury_process,
|
|
token_distribution: token_process,
|
|
membership: membership_process,
|
|
config,
|
|
security: SecurityPolicies::default(),
|
|
};
|
|
|
|
Ok(dao)
|
|
}
|
|
|
|
fn create_governance_process(
|
|
founders: &[Device],
|
|
config: &DaoConfiguration,
|
|
) -> Result<Process> {
|
|
let mut process = Process::new(OutPoint::null());
|
|
|
|
// Rôles initiaux
|
|
let founder_ids: Vec<OutPoint> = founders.iter()
|
|
.map(|f| f.get_pairing_commitment().unwrap())
|
|
.collect();
|
|
|
|
let roles = Roles::new(BTreeMap::from([
|
|
// Founders: Contrôle total initial
|
|
("founder".to_string(), RoleDefinition {
|
|
members: founder_ids.clone(),
|
|
validation_rules: vec![
|
|
ValidationRule::new(0.67, vec!["proposals", "config", "roles"], 1.0)?,
|
|
],
|
|
storages: vec![],
|
|
}),
|
|
|
|
// Members: Peuvent voter et proposer
|
|
("member".to_string(), RoleDefinition {
|
|
members: vec![], // Sera rempli au fur et à mesure
|
|
validation_rules: vec![
|
|
ValidationRule::new(0.01, vec!["proposals"], 0.5)?,
|
|
ValidationRule::new(0.0, vec!["votes"], 0.5)?,
|
|
],
|
|
storages: vec![],
|
|
}),
|
|
|
|
// Guardians: Peuvent annuler des propositions
|
|
("guardian".to_string(), RoleDefinition {
|
|
members: founder_ids.clone(),
|
|
validation_rules: vec![
|
|
ValidationRule::new(0.51, vec!["cancellations"], 1.0)?,
|
|
],
|
|
storages: vec![],
|
|
}),
|
|
|
|
// Emergency: Exécution rapide
|
|
("emergency".to_string(), RoleDefinition {
|
|
members: founder_ids.clone(),
|
|
validation_rules: vec![
|
|
ValidationRule::new(0.9, vec!["emergency_actions"], 1.0)?,
|
|
],
|
|
storages: vec![],
|
|
}),
|
|
]));
|
|
|
|
// État initial
|
|
let initial_data = json!({
|
|
"name": config.name,
|
|
"description": config.description,
|
|
"proposals": [],
|
|
"members": founder_ids.iter().map(|id| {
|
|
json!({
|
|
"id": hex::encode(id.txid.as_byte_array()),
|
|
"voting_power": 1,
|
|
"joined_at": 0,
|
|
})
|
|
}).collect::<Vec<_>>(),
|
|
"config": config,
|
|
});
|
|
|
|
let initial_state = ProcessState::new(
|
|
process.get_process_tip()?,
|
|
Pcd::new(BTreeMap::new()),
|
|
initial_data.try_into()?,
|
|
roles,
|
|
)?;
|
|
|
|
// Signatures des founders
|
|
let mut validation_tokens = vec![];
|
|
for founder in founders {
|
|
let spend_key: SecretKey = founder.get_sp_client().get_spend_key().try_into()?;
|
|
let message_hash = initial_state.get_message_hash(true)?;
|
|
validation_tokens.push(Proof::new(message_hash, spend_key));
|
|
}
|
|
initial_state.validation_tokens = validation_tokens;
|
|
|
|
process.insert_concurrent_state(initial_state)?;
|
|
|
|
Ok(process)
|
|
}
|
|
```
|
|
|
|
### 8.3 Cycle de vie complet
|
|
|
|
```
|
|
┌─────────────────────────────────────────────────────────┐
|
|
│ PHASE 1: INITIALISATION │
|
|
│ ├─ Création des processus (gouvernance, trésorerie) │
|
|
│ ├─ Distribution initiale de tokens │
|
|
│ ├─ Définition des rôles et permissions │
|
|
│ └─ Commit initial on-chain │
|
|
└─────────────────┬───────────────────────────────────────┘
|
|
│
|
|
▼
|
|
┌─────────────────────────────────────────────────────────┐
|
|
│ PHASE 2: CROISSANCE │
|
|
│ ├─ Admission de nouveaux membres │
|
|
│ ├─ Propositions et votes actifs │
|
|
│ ├─ Gestion de trésorerie │
|
|
│ └─ Évolution de la gouvernance │
|
|
└─────────────────┬───────────────────────────────────────┘
|
|
│
|
|
▼
|
|
┌─────────────────────────────────────────────────────────┐
|
|
│ PHASE 3: MATURITÉ │
|
|
│ ├─ Décentralisation progressive │
|
|
│ ├─ Réduction du pouvoir des founders │
|
|
│ ├─ Délégation de responsabilités │
|
|
│ └─ Optimisation des processus │
|
|
└─────────────────┬───────────────────────────────────────┘
|
|
│
|
|
▼
|
|
┌─────────────────────────────────────────────────────────┐
|
|
│ PHASE 4: AUTONOMIE │
|
|
│ ├─ Gouvernance entièrement décentralisée │
|
|
│ ├─ Exécution automatique de propositions │
|
|
│ ├─ Intégration avec d'autres protocoles │
|
|
│ └─ Évolution continue │
|
|
└─────────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
---
|
|
|
|
## Conclusion
|
|
|
|
### Points forts d'une DAO sur 4NK
|
|
|
|
✅ **Identité cryptographique** : Silent Payments Bitcoin (souveraineté)
|
|
✅ **Gouvernance on-chain** : Immuabilité et traçabilité complète
|
|
✅ **Flexibilité des rôles** : ValidationRules adaptables
|
|
✅ **Trésorerie native** : Gestion Bitcoin multisig
|
|
✅ **Sécurité cryptographique** : Signatures Schnorr, Merkle commitments
|
|
✅ **Multi-device** : Pairing pour résilience
|
|
✅ **Auditabilité** : Tous les états sur blockchain
|
|
✅ **Pas de smart contracts** : Pas de vulnérabilités Solidity
|
|
|
|
### Défis techniques
|
|
|
|
⚠️ **Complexité** : Architecture multi-processus
|
|
⚠️ **Coûts** : Frais Bitcoin par état
|
|
⚠️ **Latence** : Confirmations blockchain (10 min)
|
|
⚠️ **Scalabilité** : Limité par débit Bitcoin
|
|
⚠️ **UX** : Courbe d'apprentissage
|
|
|
|
### Recommandations
|
|
|
|
1. **Démarrage** : Utiliser un petit groupe de founders de confiance
|
|
2. **Décentralisation progressive** : Réduire le pouvoir des founders sur 6-12 mois
|
|
3. **Tests extensifs** : Déployer d'abord sur testnet/signet
|
|
4. **Auditabilité** : Outils de monitoring et dashboards
|
|
5. **Sécurité** : Audits réguliers, bug bounties
|
|
|
|
### Prochaines étapes
|
|
|
|
- 🔄 **Lightning Network** : Votes off-chain avec règlement on-chain
|
|
- 🔄 **ZK-SNARKs** : Vote confidentiel vérifiable
|
|
- 🔄 **Cross-chain bridges** : Interopérabilité avec autres blockchains
|
|
- 🔄 **Optimisations** : Batch voting, état compressé
|
|
|
|
---
|
|
|
|
**Document complet:** 165 pages
|
|
**Code de référence:** https://git.4nkweb.com/4nk/dao-reference
|
|
**Contact:** dao@4nkweb.com
|
|
|