Что, если демократию можно запрограммировать? Без взяток, бюрократии и человеческого фактора. DAO — децентрализованные автономные организации — стремятся заменить привычные формы управления кодом. Это статья — не объяснение "что такое DAO" на пальцах, а погружение в кишки смарт-контрактов, проблемы DAO-архитектуры и возможный путь к новому типу общества, в котором код действительно становится законом.
Некоторые идеи звучат как научная фантастика... пока ты не понимаешь, что они уже реализованы. DAO — именно такая штука. Казалось бы, зачем кому-то передавать власть куску кода на блокчейне? Но как только ты сталкиваешься с первым бесконечно медленным собранием в Zoom, где все переговариваются и никто ничего не решает — DAO начинает выглядеть не такой уж и странной идеей.
Когда не хватает времени на бюрократию, а бюджеты ограничены, лучшее решение — не нанимать ещё одного менеджера, а вырезать их из уравнения вообще. И пусть Ethereum решает.
Что такое DAO: коротко и по делу
DAO — это организация без централизованного управления, где правила и логика работы зашиты в смарт-контракты. Ни начальников, ни офисов, ни уставов, которые можно переписать задним числом. Только код, который нельзя (почти) изменить.
Как это работает
Представим DAO, которое управляет инвестиционным фондом. Каждый участник держит токены, которые дают право голоса. Кто сколько вложил — столько и голосов. Всё управление — через голосование. Хотите инвестировать в проект X? Создаёте предложение, голосуете, и если большинство «за» — смарт-контракт переводит деньги.
Пример базового DAO на Rust
```rust
// Язык: Rust (с использованием библиотеки ink! для Substrate)
#![cfg_attr(not(feature = "std"), no_std)]
use ink_lang as ink;
#[ink::contract]
pub mod simple_dao {
use ink_storage::collections::{HashMap as StorageHashMap, Vec as StorageVec};
#[derive(Default)]
#[ink(storage)]
pub struct SimpleDAO {
shares: StorageHashMap<AccountId, Balance>,
members: StorageVec<AccountId>,
proposals: StorageVec<Proposal>,
}
#[derive(scale::Encode, scale::Decode, Clone, Default)]
#[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
pub struct Proposal {
recipient: AccountId,
amount: Balance,
votes: Balance,
deadline: Timestamp,
executed: bool,
}
impl SimpleDAO {
#[ink(constructor)]
pub fn new() -> Self {
let caller = Self::env().caller();
let mut dao = Self::default();
dao.members.push(caller);
dao.shares.insert(caller, 100);
dao
}
#[ink(message, payable)]
pub fn contribute(&mut self) {
let caller = self.env().caller();
let value = self.env().transferred_value();
let entry = self.shares.entry(caller).or_insert(0);
*entry += value;
self.members.push(caller);
}
#[ink(message)]
pub fn create_proposal(&mut self, recipient: AccountId, amount: Balance) {
let caller = self.env().caller();
assert!(self.shares.contains_key(&caller), "Not a member");
let proposal = Proposal {
recipient,
amount,
votes: 0,
deadline: self.env().block_timestamp() + 259200000, // 3 days in ms
executed: false,
};
self.proposals.push(proposal);
}
#[ink(message)]
pub fn vote(&mut self, proposal_id: u32) {
let caller = self.env().caller();
let share = self.shares.get(&caller).copied().unwrap_or(0);
assert!(share > 0, "Not a member");
let proposal = &mut self.proposals[proposal_id as usize];
assert!(self.env().block_timestamp() < proposal.deadline, "Voting ended");
proposal.votes += share;
}
#[ink(message)]
pub fn execute_proposal(&mut self, proposal_id: u32) {
let proposal = &mut self.proposals[proposal_id as usize];
assert!(self.env().block_timestamp() >= proposal.deadline, "Voting not ended");
assert!(!proposal.executed, "Already executed");
if proposal.votes > self.total_shares() / 2 {
self.env().transfer(proposal.recipient, proposal.amount).unwrap();
proposal.executed = true;
}
}
fn total_shares(&self) -> Balance {
self.members.iter().map(|m| self.shares.get(m).copied().unwrap_or(0)).sum()
}
}
}Альтернативный взгляд: реализация DAO на Python с использованием Brownie и Web3.py
# Язык: Python
from brownie import accounts, network, Contract, Wei
from web3 import Web3
class DAO:
def __init__(self):
self.members = {}
self.proposals = []
def contribute(self, member, amount):
if member not in self.members:
self.members[member] = 0
self.members[member] += amount
def create_proposal(self, recipient, amount):
proposal = {
"recipient": recipient,
"amount": amount,
"votes": 0,
"executed": False,
"voters": set()
}
self.proposals.append(proposal)
def vote(self, member, proposal_id):
if member in self.members and member not in self.proposals[proposal_id]['voters']:
self.proposals[proposal_id]['votes'] += self.members[member]
self.proposals[proposal_id]['voters'].add(member)
def execute(self, proposal_id):
proposal = self.proposals[proposal_id]
if proposal['votes'] > self.total_shares() / 2 and not proposal['executed']:
print(f"Executing transfer to {proposal['recipient']} amount {proposal['amount']}")
proposal['executed'] = True
def total_shares(self):
return sum(self.members.values())
# Пример использования
my_dao = DAO()
my_dao.contribute("alice", 100)
my_dao.contribute("bob", 50)
my_dao.create_proposal("projectX", 120)
my_dao.vote("alice", 0)
my_dao.vote("bob", 0)
my_dao.execute(0)Почему это может сработать
DAO — это не столько про технологии, сколько про доверие. Ты не доверяешь человеку, но можешь доверять коду. Если правила прописаны, они будут соблюдены. Это бескомпромиссная прозрачность.
DAO особенно интересны для:
стран с коррупцией;
распределённых команд;
цифровых сообществ без юридического лица;
и вообще там, где нет ни одного "главного".
Подытожим
DAO — штука странная. Она как бы и не нужна... пока ты не увидел, насколько плохо работает всё остальное. Конечно, коды не заменят здравого смысла. Конечно, у DAO есть свои баги и уязвимости. Но одно можно сказать точно: когда код становится законом — всё становится иначе. И пока кто-то пишет очередную презентацию для инвесторов, кто-то другой просто выкатывает DAO и говорит: «голосуйте».
