use std::{collections::HashMap, fmt};
use lazy_static::lazy_static;
use num_bigint::BigUint;
use rand::rngs::OsRng;
use rusqlite::types::Value;
use darkfi::{
tx::{ContractCallLeaf, Transaction, TransactionBuilder},
util::parse::{decode_base10, encode_base10},
zk::{empty_witnesses, halo2::Field, ProvingKey, ZkCircuit},
zkas::ZkBinary,
Error, Result,
};
use darkfi_dao_contract::{
blockwindow,
client::{
make_mint_call, DaoAuthMoneyTransferCall, DaoExecCall, DaoProposeCall,
DaoProposeStakeInput, DaoVoteCall, DaoVoteInput,
},
model::{
Dao, DaoAuthCall, DaoBulla, DaoExecParams, DaoMintParams, DaoProposal, DaoProposalBulla,
DaoProposeParams, DaoVoteParams,
},
DaoFunction, DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_ENC_COIN_NS,
DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS, DAO_CONTRACT_ZKAS_DAO_EXEC_NS,
DAO_CONTRACT_ZKAS_DAO_MINT_NS, DAO_CONTRACT_ZKAS_DAO_PROPOSE_INPUT_NS,
DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS, DAO_CONTRACT_ZKAS_DAO_VOTE_INPUT_NS,
DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS,
};
use darkfi_money_contract::{
client::transfer_v1::{select_coins, TransferCallBuilder, TransferCallInput},
model::{CoinAttributes, Nullifier, TokenId},
MoneyFunction, MONEY_CONTRACT_ZKAS_BURN_NS_V1, MONEY_CONTRACT_ZKAS_FEE_NS_V1,
MONEY_CONTRACT_ZKAS_MINT_NS_V1,
};
use darkfi_sdk::{
bridgetree,
crypto::{
poseidon_hash,
smt::{MemoryStorageFp, PoseidonFp, SmtMemoryFp, EMPTY_NODES_FP},
util::{fp_mod_fv, fp_to_u64},
BaseBlind, Blind, FuncId, FuncRef, Keypair, MerkleNode, MerkleTree, PublicKey, ScalarBlind,
SecretKey, DAO_CONTRACT_ID, MONEY_CONTRACT_ID,
},
dark_tree::DarkTree,
pasta::pallas,
tx::TransactionHash,
ContractCall,
};
use darkfi_serial::{
async_trait, deserialize_async, serialize_async, AsyncEncodable, SerialDecodable,
SerialEncodable,
};
use crate::{
convert_named_params,
error::{WalletDbError, WalletDbResult},
money::{BALANCE_BASE10_DECIMALS, MONEY_SMT_COL_KEY, MONEY_SMT_COL_VALUE, MONEY_SMT_TABLE},
walletdb::{WalletSmt, WalletStorage},
Drk,
};
lazy_static! {
pub static ref DAO_DAOS_TABLE: String = format!("{}_dao_daos", DAO_CONTRACT_ID.to_string());
pub static ref DAO_TREES_TABLE: String = format!("{}_dao_trees", DAO_CONTRACT_ID.to_string());
pub static ref DAO_COINS_TABLE: String = format!("{}_dao_coins", DAO_CONTRACT_ID.to_string());
pub static ref DAO_PROPOSALS_TABLE: String =
format!("{}_dao_proposals", DAO_CONTRACT_ID.to_string());
pub static ref DAO_VOTES_TABLE: String = format!("{}_dao_votes", DAO_CONTRACT_ID.to_string());
}
pub const DAO_DAOS_COL_BULLA: &str = "bulla";
pub const DAO_DAOS_COL_NAME: &str = "name";
pub const DAO_DAOS_COL_PARAMS: &str = "params";
pub const DAO_DAOS_COL_LEAF_POSITION: &str = "leaf_position";
pub const DAO_DAOS_COL_TX_HASH: &str = "tx_hash";
pub const DAO_DAOS_COL_CALL_INDEX: &str = "call_index";
pub const DAO_TREES_COL_DAOS_TREE: &str = "daos_tree";
pub const DAO_TREES_COL_PROPOSALS_TREE: &str = "proposals_tree";
pub const DAO_PROPOSALS_COL_BULLA: &str = "bulla";
pub const DAO_PROPOSALS_COL_DAO_BULLA: &str = "dao_bulla";
pub const DAO_PROPOSALS_COL_PROPOSAL: &str = "proposal";
pub const DAO_PROPOSALS_COL_DATA: &str = "data";
pub const DAO_PROPOSALS_COL_LEAF_POSITION: &str = "leaf_position";
pub const DAO_PROPOSALS_COL_MONEY_SNAPSHOT_TREE: &str = "money_snapshot_tree";
pub const DAO_PROPOSALS_COL_NULLIFIERS_SMT_SNAPSHOT: &str = "nullifiers_smt_snapshot";
pub const DAO_PROPOSALS_COL_TX_HASH: &str = "tx_hash";
pub const DAO_PROPOSALS_COL_CALL_INDEX: &str = "call_index";
pub const DAO_PROPOSALS_COL_EXEC_TX_HASH: &str = "exec_tx_hash";
pub const DAO_VOTES_COL_PROPOSAL_BULLA: &str = "proposal_bulla";
pub const DAO_VOTES_COL_VOTE_OPTION: &str = "vote_option";
pub const DAO_VOTES_COL_YES_VOTE_BLIND: &str = "yes_vote_blind";
pub const DAO_VOTES_COL_ALL_VOTE_VALUE: &str = "all_vote_value";
pub const DAO_VOTES_COL_ALL_VOTE_BLIND: &str = "all_vote_blind";
pub const DAO_VOTES_COL_TX_HASH: &str = "tx_hash";
pub const DAO_VOTES_COL_CALL_INDEX: &str = "call_index";
pub const DAO_VOTES_COL_NULLIFIERS: &str = "nullifiers";
#[derive(Debug, Clone, SerialEncodable, SerialDecodable)]
pub struct DaoParams {
pub dao: Dao,
pub secret_key: SecretKey,
}
impl DaoParams {
pub fn new(
proposer_limit: u64,
quorum: u64,
approval_ratio_base: u64,
approval_ratio_quot: u64,
gov_token_id: TokenId,
secret_key: SecretKey,
bulla_blind: BaseBlind,
) -> Self {
let dao = Dao {
proposer_limit,
quorum,
approval_ratio_base,
approval_ratio_quot,
gov_token_id,
public_key: PublicKey::from_secret(secret_key),
bulla_blind,
};
Self { dao, secret_key }
}
}
impl fmt::Display for DaoParams {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let s = format!(
"{}\n{}\n{}: {} ({})\n{}: {} ({})\n{}: {}\n{}: {}\n{}: {}\n{}: {}\n{}: {:?}",
"DAO Parameters",
"==============",
"Proposer limit",
encode_base10(self.dao.proposer_limit, BALANCE_BASE10_DECIMALS),
self.dao.proposer_limit,
"Quorum",
encode_base10(self.dao.quorum, BALANCE_BASE10_DECIMALS),
self.dao.quorum,
"Approval ratio",
self.dao.approval_ratio_quot as f64 / self.dao.approval_ratio_base as f64,
"Governance Token ID",
self.dao.gov_token_id,
"Public key",
self.dao.public_key,
"Secret key",
self.secret_key,
"Bulla blind",
self.dao.bulla_blind,
);
write!(f, "{}", s)
}
}
#[derive(Debug, Clone)]
pub struct DaoRecord {
pub name: String,
pub params: DaoParams,
pub leaf_position: Option<bridgetree::Position>,
pub tx_hash: Option<TransactionHash>,
pub call_index: Option<u8>,
}
impl DaoRecord {
pub fn new(
name: String,
params: DaoParams,
leaf_position: Option<bridgetree::Position>,
tx_hash: Option<TransactionHash>,
call_index: Option<u8>,
) -> Self {
Self { name, params, leaf_position, tx_hash, call_index }
}
pub fn bulla(&self) -> DaoBulla {
self.params.dao.to_bulla()
}
pub fn keypair(&self) -> Keypair {
let public = PublicKey::from_secret(self.params.secret_key);
Keypair { public, secret: self.params.secret_key }
}
}
impl fmt::Display for DaoRecord {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let leaf_position = match self.leaf_position {
Some(p) => format!("{p:?}"),
None => "None".to_string(),
};
let tx_hash = match self.tx_hash {
Some(t) => format!("{t}"),
None => "None".to_string(),
};
let call_index = match self.call_index {
Some(c) => format!("{c}"),
None => "None".to_string(),
};
let s = format!(
"{}\n{}\n{}: {}\n{}: {}\n{}: {} ({})\n{}: {} ({})\n{}: {}\n{}: {}\n{}: {}\n{}: {}\n{}: {}\n{}: {}\n{}: {}\n{}: {}",
"DAO Parameters",
"==============",
"Name",
self.name,
"Bulla",
self.bulla(),
"Proposer limit",
encode_base10(self.params.dao.proposer_limit, BALANCE_BASE10_DECIMALS),
self.params.dao.proposer_limit,
"Quorum",
encode_base10(self.params.dao.quorum, BALANCE_BASE10_DECIMALS),
self.params.dao.quorum,
"Approval ratio",
self.params.dao.approval_ratio_quot as f64 / self.params.dao.approval_ratio_base as f64,
"Governance Token ID",
self.params.dao.gov_token_id,
"Public key",
self.params.dao.public_key,
"Secret key",
self.params.secret_key,
"Bulla blind",
self.params.dao.bulla_blind,
"Leaf position",
leaf_position,
"Transaction hash",
tx_hash,
"Call index",
call_index,
);
write!(f, "{}", s)
}
}
#[derive(Debug, Clone, SerialEncodable, SerialDecodable)]
pub struct ProposalRecord {
pub proposal: DaoProposal,
pub data: Option<Vec<u8>>,
pub leaf_position: Option<bridgetree::Position>,
pub money_snapshot_tree: Option<MerkleTree>,
pub nullifiers_smt_snapshot: Option<HashMap<BigUint, pallas::Base>>,
pub tx_hash: Option<TransactionHash>,
pub call_index: Option<u8>,
pub exec_tx_hash: Option<TransactionHash>,
}
impl ProposalRecord {
pub fn bulla(&self) -> DaoProposalBulla {
self.proposal.to_bulla()
}
}
impl fmt::Display for ProposalRecord {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let leaf_position = match self.leaf_position {
Some(p) => format!("{p:?}"),
None => "None".to_string(),
};
let tx_hash = match self.tx_hash {
Some(t) => format!("{t}"),
None => "None".to_string(),
};
let call_index = match self.call_index {
Some(c) => format!("{c}"),
None => "None".to_string(),
};
let s = format!(
"{}\n{}\n{}: {}\n{}: {}\n{}: {}\n{}: {}\n{}: {}\n{}: {}\n{}: {} ({})",
"Proposal parameters",
"===================",
"Bulla",
self.bulla(),
"DAO Bulla",
self.proposal.dao_bulla,
"Proposal leaf position",
leaf_position,
"Proposal transaction hash",
tx_hash,
"Proposal call index",
call_index,
"Creation block window",
self.proposal.creation_blockwindow,
"Duration",
self.proposal.duration_blockwindows,
"Block windows"
);
write!(f, "{}", s)
}
}
#[derive(Debug, Clone)]
pub struct VoteRecord {
pub id: u64,
pub proposal: DaoProposalBulla,
pub vote_option: bool,
pub yes_vote_blind: ScalarBlind,
pub all_vote_value: u64,
pub all_vote_blind: ScalarBlind,
pub tx_hash: TransactionHash,
pub call_index: u8,
pub nullifiers: Vec<Nullifier>,
}
impl Drk {
pub async fn initialize_dao(&self) -> WalletDbResult<()> {
let wallet_schema = include_str!("../dao.sql");
self.wallet.exec_batch_sql(wallet_schema)?;
if self.wallet.query_single(&DAO_TREES_TABLE, &[DAO_TREES_COL_DAOS_TREE], &[]).is_err() {
println!("Initializing DAO Merkle trees");
let tree = MerkleTree::new(1);
self.put_dao_trees(&tree, &tree).await?;
println!("Successfully initialized Merkle trees for the DAO contract");
}
Ok(())
}
pub async fn put_dao_trees(
&self,
daos_tree: &MerkleTree,
proposals_tree: &MerkleTree,
) -> WalletDbResult<()> {
let query = format!("DELETE FROM {};", *DAO_TREES_TABLE);
self.wallet.exec_sql(&query, &[])?;
let query = format!(
"INSERT INTO {} ({}, {}) VALUES (?1, ?2);",
*DAO_TREES_TABLE, DAO_TREES_COL_DAOS_TREE, DAO_TREES_COL_PROPOSALS_TREE,
);
self.wallet.exec_sql(
&query,
rusqlite::params![
serialize_async(daos_tree).await,
serialize_async(proposals_tree).await
],
)
}
pub async fn get_dao_trees(&self) -> Result<(MerkleTree, MerkleTree)> {
let row = match self.wallet.query_single(&DAO_TREES_TABLE, &[], &[]) {
Ok(r) => r,
Err(e) => {
return Err(Error::DatabaseError(format!(
"[get_dao_trees] Trees retrieval failed: {e:?}"
)))
}
};
let Value::Blob(ref daos_tree_bytes) = row[0] else {
return Err(Error::ParseFailed("[get_dao_trees] DAO tree bytes parsing failed"))
};
let daos_tree = deserialize_async(daos_tree_bytes).await?;
let Value::Blob(ref proposals_tree_bytes) = row[1] else {
return Err(Error::ParseFailed("[get_dao_trees] Proposals tree bytes parsing failed"))
};
let proposals_tree = deserialize_async(proposals_tree_bytes).await?;
Ok((daos_tree, proposals_tree))
}
pub async fn get_dao_secrets(&self) -> Result<Vec<SecretKey>> {
let daos = self.get_daos().await?;
let mut ret = Vec::with_capacity(daos.len());
for dao in daos {
ret.push(dao.params.secret_key);
}
Ok(ret)
}
async fn parse_dao_record(&self, row: &[Value]) -> Result<DaoRecord> {
let Value::Text(ref name) = row[1] else {
return Err(Error::ParseFailed("[parse_dao_record] Name parsing failed"))
};
let name = name.clone();
let Value::Blob(ref params_bytes) = row[2] else {
return Err(Error::ParseFailed("[parse_dao_record] Params bytes parsing failed"))
};
let params = deserialize_async(params_bytes).await?;
let leaf_position = match row[3] {
Value::Blob(ref leaf_position_bytes) => {
Some(deserialize_async(leaf_position_bytes).await?)
}
Value::Null => None,
_ => {
return Err(Error::ParseFailed(
"[parse_dao_record] Leaf position bytes parsing failed",
))
}
};
let tx_hash = match row[4] {
Value::Blob(ref tx_hash_bytes) => Some(deserialize_async(tx_hash_bytes).await?),
Value::Null => None,
_ => {
return Err(Error::ParseFailed(
"[parse_dao_record] Transaction hash bytes parsing failed",
))
}
};
let call_index = match row[5] {
Value::Integer(call_index) => {
let Ok(call_index) = u8::try_from(call_index) else {
return Err(Error::ParseFailed("[parse_dao_record] Call index parsing failed"))
};
Some(call_index)
}
Value::Null => None,
_ => return Err(Error::ParseFailed("[parse_dao_record] Call index parsing failed")),
};
let dao = DaoRecord::new(name, params, leaf_position, tx_hash, call_index);
Ok(dao)
}
pub async fn get_daos(&self) -> Result<Vec<DaoRecord>> {
let rows = match self.wallet.query_multiple(&DAO_DAOS_TABLE, &[], &[]) {
Ok(r) => r,
Err(e) => {
return Err(Error::DatabaseError(format!("[get_daos] DAOs retrieval failed: {e:?}")))
}
};
let mut daos = Vec::with_capacity(rows.len());
for row in rows {
daos.push(self.parse_dao_record(&row).await?);
}
Ok(daos)
}
async fn parse_dao_proposal(&self, row: &[Value]) -> Result<ProposalRecord> {
let Value::Blob(ref proposal_bytes) = row[2] else {
return Err(Error::ParseFailed(
"[get_dao_proposals] Proposal bytes bytes parsing failed",
))
};
let proposal = deserialize_async(proposal_bytes).await?;
let data = match row[3] {
Value::Blob(ref data_bytes) => Some(data_bytes.clone()),
Value::Null => None,
_ => return Err(Error::ParseFailed("[get_dao_proposals] Data bytes parsing failed")),
};
let leaf_position = match row[4] {
Value::Blob(ref leaf_position_bytes) => {
Some(deserialize_async(leaf_position_bytes).await?)
}
Value::Null => None,
_ => {
return Err(Error::ParseFailed(
"[get_dao_proposals] Leaf position bytes parsing failed",
))
}
};
let money_snapshot_tree = match row[5] {
Value::Blob(ref money_snapshot_tree_bytes) => {
Some(deserialize_async(money_snapshot_tree_bytes).await?)
}
Value::Null => None,
_ => {
return Err(Error::ParseFailed(
"[get_dao_proposals] Money snapshot tree bytes parsing failed",
))
}
};
let nullifiers_smt_snapshot = match row[6] {
Value::Blob(ref nullifiers_smt_snapshot_bytes) => {
Some(deserialize_async(nullifiers_smt_snapshot_bytes).await?)
}
Value::Null => None,
_ => {
return Err(Error::ParseFailed(
"[get_dao_proposals] Nullifiers SMT snapshot bytes parsing failed",
))
}
};
let tx_hash = match row[7] {
Value::Blob(ref tx_hash_bytes) => Some(deserialize_async(tx_hash_bytes).await?),
Value::Null => None,
_ => {
return Err(Error::ParseFailed(
"[get_dao_proposals] Transaction hash bytes parsing failed",
))
}
};
let call_index = match row[8] {
Value::Integer(call_index) => {
let Ok(call_index) = u8::try_from(call_index) else {
return Err(Error::ParseFailed("[get_dao_proposals] Call index parsing failed"))
};
Some(call_index)
}
Value::Null => None,
_ => return Err(Error::ParseFailed("[get_dao_proposals] Call index parsing failed")),
};
let exec_tx_hash = match row[9] {
Value::Blob(ref exec_tx_hash_bytes) => {
Some(deserialize_async(exec_tx_hash_bytes).await?)
}
Value::Null => None,
_ => {
return Err(Error::ParseFailed(
"[get_dao_proposals] Execution transaction hash bytes parsing failed",
))
}
};
Ok(ProposalRecord {
proposal,
data,
leaf_position,
money_snapshot_tree,
nullifiers_smt_snapshot,
tx_hash,
call_index,
exec_tx_hash,
})
}
pub async fn get_dao_proposals(&self, name: &str) -> Result<Vec<ProposalRecord>> {
let Ok(dao) = self.get_dao_by_name(name).await else {
return Err(Error::DatabaseError(format!(
"[get_dao_proposals] DAO with name {name} not found in wallet"
)))
};
let rows = match self.wallet.query_multiple(
&DAO_PROPOSALS_TABLE,
&[],
convert_named_params! {(DAO_PROPOSALS_COL_DAO_BULLA, serialize_async(&dao.bulla()).await)},
) {
Ok(r) => r,
Err(e) => {
return Err(Error::DatabaseError(format!(
"[get_dao_proposals] Proposals retrieval failed: {e:?}"
)))
}
};
let mut proposals = Vec::with_capacity(rows.len());
for row in rows {
let proposal = self.parse_dao_proposal(&row).await?;
proposals.push(proposal);
}
Ok(proposals)
}
async fn apply_dao_mint_data(
&self,
new_bulla: DaoBulla,
tx_hash: TransactionHash,
call_index: u8,
) -> Result<()> {
let daos = self.get_daos().await?;
let (mut daos_tree, proposals_tree) = self.get_dao_trees().await?;
daos_tree.append(MerkleNode::from(new_bulla.inner()));
for dao in &daos {
if dao.bulla() == new_bulla {
println!(
"[apply_dao_mint_data] Found minted DAO {}, noting down for wallet update",
new_bulla
);
let mut dao_to_confirm = dao.clone();
dao_to_confirm.leaf_position = daos_tree.mark();
dao_to_confirm.tx_hash = Some(tx_hash);
dao_to_confirm.call_index = Some(call_index);
if let Err(e) = self.put_dao_trees(&daos_tree, &proposals_tree).await {
return Err(Error::DatabaseError(format!(
"[apply_dao_mint_data] Put DAO tree failed: {e:?}"
)))
}
if let Err(e) = self.confirm_dao(&dao_to_confirm).await {
return Err(Error::DatabaseError(format!(
"[apply_dao_mint_data] Confirm DAO failed: {e:?}"
)))
}
break
}
}
Ok(())
}
async fn apply_dao_propose_data(
&self,
params: DaoProposeParams,
tx_hash: TransactionHash,
call_index: u8,
) -> Result<()> {
let daos = self.get_daos().await?;
let (daos_tree, mut proposals_tree) = self.get_dao_trees().await?;
proposals_tree.append(MerkleNode::from(params.proposal_bulla.inner()));
for dao in &daos {
if let Ok(note) = params.note.decrypt::<DaoProposal>(&dao.params.secret_key) {
println!("[apply_dao_propose_data] Managed to decrypt DAO proposal note");
let money_tree = self.get_money_tree().await?;
let nullifiers_smt = self.get_nullifiers_smt().await?;
let our_proposal =
match self.get_dao_proposal_by_bulla(¶ms.proposal_bulla).await {
Ok(p) => {
let mut our_proposal = p;
our_proposal.leaf_position = proposals_tree.mark();
our_proposal.money_snapshot_tree = Some(money_tree);
our_proposal.nullifiers_smt_snapshot = Some(nullifiers_smt);
our_proposal.tx_hash = Some(tx_hash);
our_proposal.call_index = Some(call_index);
our_proposal
}
Err(_) => ProposalRecord {
proposal: note,
data: None,
leaf_position: proposals_tree.mark(),
money_snapshot_tree: Some(money_tree),
nullifiers_smt_snapshot: Some(nullifiers_smt),
tx_hash: Some(tx_hash),
call_index: Some(call_index),
exec_tx_hash: None,
},
};
if let Err(e) = self.put_dao_trees(&daos_tree, &proposals_tree).await {
return Err(Error::DatabaseError(format!(
"[apply_dao_propose_data] Put DAO tree failed: {e:?}"
)))
}
if let Err(e) = self.put_dao_proposal(&our_proposal).await {
return Err(Error::DatabaseError(format!(
"[apply_dao_propose_data] Put DAO proposals failed: {e:?}"
)))
}
break
}
}
Ok(())
}
async fn apply_dao_vote_data(
&self,
params: DaoVoteParams,
tx_hash: TransactionHash,
call_index: u8,
) -> Result<()> {
let Ok(proposal) = self.get_dao_proposal_by_bulla(¶ms.proposal_bulla).await else {
return Ok(())
};
let dao = match self.get_dao_by_bulla(&proposal.proposal.dao_bulla).await {
Ok(d) => d,
Err(e) => {
return Err(Error::DatabaseError(format!(
"[apply_dao_vote_data] Couldn't find proposal {} DAO {}: {e}",
proposal.bulla(),
proposal.proposal.dao_bulla,
)))
}
};
let note = match params.note.decrypt_unsafe(&dao.params.secret_key) {
Ok(n) => n,
Err(e) => {
return Err(Error::DatabaseError(format!(
"[apply_dao_vote_data] Couldn't decrypt proposal {} vote with DAO {} keys: {e}",
proposal.bulla(),
proposal.proposal.dao_bulla,
)))
}
};
let vote_option = fp_to_u64(note[0]).unwrap();
if vote_option > 1 {
return Err(Error::DatabaseError(format!(
"[apply_dao_vote_data] Malformed vote for proposal {}: {vote_option}",
proposal.bulla(),
)))
}
let vote_option = vote_option != 0;
let yes_vote_blind = Blind(fp_mod_fv(note[1]));
let all_vote_value = fp_to_u64(note[2]).unwrap();
let all_vote_blind = Blind(fp_mod_fv(note[3]));
let v = VoteRecord {
id: 0, proposal: params.proposal_bulla,
vote_option,
yes_vote_blind,
all_vote_value,
all_vote_blind,
tx_hash,
call_index,
nullifiers: params.inputs.iter().map(|i| i.vote_nullifier).collect(),
};
if let Err(e) = self.put_dao_vote(&v).await {
return Err(Error::DatabaseError(format!(
"[apply_dao_vote_data] Put DAO votes failed: {e:?}"
)))
}
Ok(())
}
async fn apply_dao_exec_data(
&self,
params: DaoExecParams,
tx_hash: TransactionHash,
) -> Result<()> {
let Ok(mut proposal) = self.get_dao_proposal_by_bulla(¶ms.proposal_bulla).await else {
return Ok(())
};
proposal.exec_tx_hash = Some(tx_hash);
if let Err(e) = self.put_dao_proposal(&proposal).await {
return Err(Error::DatabaseError(format!(
"[apply_dao_exec_data] Put DAO proposal failed: {e:?}"
)))
}
Ok(())
}
pub async fn apply_tx_dao_data(
&self,
data: &[u8],
tx_hash: TransactionHash,
call_idx: u8,
) -> Result<()> {
match DaoFunction::try_from(data[0])? {
DaoFunction::Mint => {
println!("[apply_tx_dao_data] Found Dao::Mint call");
let params: DaoMintParams = deserialize_async(&data[1..]).await?;
self.apply_dao_mint_data(params.dao_bulla, tx_hash, call_idx).await
}
DaoFunction::Propose => {
println!("[apply_tx_dao_data] Found Dao::Propose call");
let params: DaoProposeParams = deserialize_async(&data[1..]).await?;
self.apply_dao_propose_data(params, tx_hash, call_idx).await
}
DaoFunction::Vote => {
println!("[apply_tx_dao_data] Found Dao::Vote call");
let params: DaoVoteParams = deserialize_async(&data[1..]).await?;
self.apply_dao_vote_data(params, tx_hash, call_idx).await
}
DaoFunction::Exec => {
println!("[apply_tx_dao_data] Found Dao::Exec call");
let params: DaoExecParams = deserialize_async(&data[1..]).await?;
self.apply_dao_exec_data(params, tx_hash).await
}
DaoFunction::AuthMoneyTransfer => {
println!("[apply_tx_dao_data] Found Dao::AuthMoneyTransfer call");
Ok(())
}
}
}
pub async fn confirm_dao(&self, dao: &DaoRecord) -> WalletDbResult<()> {
let query = format!(
"UPDATE {} SET {} = ?1, {} = ?2, {} = ?3 WHERE {} = ?4;",
*DAO_DAOS_TABLE,
DAO_DAOS_COL_LEAF_POSITION,
DAO_DAOS_COL_TX_HASH,
DAO_DAOS_COL_CALL_INDEX,
DAO_DAOS_COL_BULLA
);
self.wallet.exec_sql(
&query,
rusqlite::params![
serialize_async(&dao.leaf_position.unwrap()).await,
serialize_async(&dao.tx_hash.unwrap()).await,
dao.call_index.unwrap(),
serialize_async(&dao.bulla()).await,
],
)
}
pub async fn unconfirm_daos(&self, daos: &[DaoRecord]) -> WalletDbResult<()> {
for dao in daos {
let query = format!(
"UPDATE {} SET {} = ?1, {} = ?2, {} = ?3 WHERE {} = ?4;",
*DAO_DAOS_TABLE,
DAO_DAOS_COL_LEAF_POSITION,
DAO_DAOS_COL_TX_HASH,
DAO_DAOS_COL_CALL_INDEX,
DAO_DAOS_COL_BULLA
);
self.wallet.exec_sql(
&query,
rusqlite::params![
None::<Vec<u8>>,
None::<Vec<u8>>,
None::<u64>,
serialize_async(&dao.bulla()).await
],
)?;
}
Ok(())
}
pub async fn put_dao_proposal(&self, proposal: &ProposalRecord) -> Result<()> {
if let Err(e) = self.get_dao_by_bulla(&proposal.proposal.dao_bulla).await {
return Err(Error::DatabaseError(format!(
"[put_dao_proposal] Couldn't find proposal {} DAO {}: {e}",
proposal.bulla(),
proposal.proposal.dao_bulla
)))
}
let query = format!(
"INSERT OR REPLACE INTO {} ({}, {}, {}, {}, {}, {}, {}, {}, {}, {}) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10);",
*DAO_PROPOSALS_TABLE,
DAO_PROPOSALS_COL_BULLA,
DAO_PROPOSALS_COL_DAO_BULLA,
DAO_PROPOSALS_COL_PROPOSAL,
DAO_PROPOSALS_COL_DATA,
DAO_PROPOSALS_COL_LEAF_POSITION,
DAO_PROPOSALS_COL_MONEY_SNAPSHOT_TREE,
DAO_PROPOSALS_COL_NULLIFIERS_SMT_SNAPSHOT,
DAO_PROPOSALS_COL_TX_HASH,
DAO_PROPOSALS_COL_CALL_INDEX,
DAO_PROPOSALS_COL_EXEC_TX_HASH,
);
let data = match &proposal.data {
Some(data) => Some(data),
None => None,
};
let leaf_position = match &proposal.leaf_position {
Some(leaf_position) => Some(serialize_async(leaf_position).await),
None => None,
};
let money_snapshot_tree = match &proposal.money_snapshot_tree {
Some(money_snapshot_tree) => Some(serialize_async(money_snapshot_tree).await),
None => None,
};
let nullifiers_smt_snapshot = match &proposal.nullifiers_smt_snapshot {
Some(nullifiers_smt_snapshot) => Some(serialize_async(nullifiers_smt_snapshot).await),
None => None,
};
let tx_hash = match &proposal.tx_hash {
Some(tx_hash) => Some(serialize_async(tx_hash).await),
None => None,
};
let exec_tx_hash = match &proposal.exec_tx_hash {
Some(exec_tx_hash) => Some(serialize_async(exec_tx_hash).await),
None => None,
};
if let Err(e) = self.wallet.exec_sql(
&query,
rusqlite::params![
serialize_async(&proposal.bulla()).await,
serialize_async(&proposal.proposal.dao_bulla).await,
serialize_async(&proposal.proposal).await,
data,
leaf_position,
money_snapshot_tree,
nullifiers_smt_snapshot,
tx_hash,
proposal.call_index,
exec_tx_hash,
],
) {
return Err(Error::DatabaseError(format!(
"[put_dao_proposal] Proposal insert failed: {e:?}"
)))
};
Ok(())
}
pub async fn unconfirm_proposals(&self, proposals: &[ProposalRecord]) -> WalletDbResult<()> {
for proposal in proposals {
let query = format!(
"UPDATE {} SET {} = ?1, {} = ?2, {} = ?3, {} = ?4, {} = ?5, {} = ?6 WHERE {} = ?7;",
*DAO_PROPOSALS_TABLE,
DAO_PROPOSALS_COL_LEAF_POSITION,
DAO_PROPOSALS_COL_MONEY_SNAPSHOT_TREE,
DAO_PROPOSALS_COL_NULLIFIERS_SMT_SNAPSHOT,
DAO_PROPOSALS_COL_TX_HASH,
DAO_PROPOSALS_COL_CALL_INDEX,
DAO_PROPOSALS_COL_EXEC_TX_HASH,
DAO_PROPOSALS_COL_BULLA
);
self.wallet.exec_sql(
&query,
rusqlite::params![
None::<Vec<u8>>,
None::<Vec<u8>>,
None::<Vec<u8>>,
None::<Vec<u8>>,
None::<u64>,
None::<Vec<u8>>,
serialize_async(&proposal.bulla()).await
],
)?;
}
Ok(())
}
pub async fn put_dao_vote(&self, vote: &VoteRecord) -> WalletDbResult<()> {
eprintln!("Importing DAO vote into wallet");
let query = format!(
"INSERT INTO {} ({}, {}, {}, {}, {}, {}, {}, {}) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8);",
*DAO_VOTES_TABLE,
DAO_VOTES_COL_PROPOSAL_BULLA,
DAO_VOTES_COL_VOTE_OPTION,
DAO_VOTES_COL_YES_VOTE_BLIND,
DAO_VOTES_COL_ALL_VOTE_VALUE,
DAO_VOTES_COL_ALL_VOTE_BLIND,
DAO_VOTES_COL_TX_HASH,
DAO_VOTES_COL_CALL_INDEX,
DAO_VOTES_COL_NULLIFIERS,
);
self.wallet.exec_sql(
&query,
rusqlite::params![
serialize_async(&vote.proposal).await,
vote.vote_option as u64,
serialize_async(&vote.yes_vote_blind).await,
serialize_async(&vote.all_vote_value).await,
serialize_async(&vote.all_vote_blind).await,
serialize_async(&vote.tx_hash).await,
vote.call_index,
serialize_async(&vote.nullifiers).await,
],
)?;
println!("DAO vote added to wallet");
Ok(())
}
pub async fn reset_dao_trees(&self) -> WalletDbResult<()> {
println!("Resetting DAO Merkle trees");
let tree = MerkleTree::new(1);
self.put_dao_trees(&tree, &tree).await?;
println!("Successfully reset DAO Merkle trees");
Ok(())
}
pub async fn reset_daos(&self) -> WalletDbResult<()> {
println!("Resetting DAO confirmations");
let daos = match self.get_daos().await {
Ok(d) => d,
Err(e) => {
println!("[reset_daos] DAOs retrieval failed: {e:?}");
return Err(WalletDbError::GenericError);
}
};
self.unconfirm_daos(&daos).await?;
println!("Successfully unconfirmed DAOs");
Ok(())
}
pub async fn reset_dao_proposals(&self) -> WalletDbResult<()> {
println!("Resetting DAO proposals confirmations");
let proposals = match self.get_proposals().await {
Ok(p) => p,
Err(e) => {
println!("[reset_dao_proposals] DAO proposals retrieval failed: {e:?}");
return Err(WalletDbError::GenericError);
}
};
self.unconfirm_proposals(&proposals).await?;
println!("Successfully unconfirmed DAO proposals");
Ok(())
}
pub fn reset_dao_votes(&self) -> WalletDbResult<()> {
println!("Resetting DAO votes");
let query = format!("DELETE FROM {};", *DAO_VOTES_TABLE);
self.wallet.exec_sql(&query, &[])
}
pub async fn import_dao(&self, name: &str, params: DaoParams) -> Result<()> {
if self.get_dao_by_name(name).await.is_ok() {
return Err(Error::DatabaseError(
"[import_dao] This DAO has already been imported".to_string(),
))
}
println!("Importing \"{name}\" DAO into the wallet");
let query = format!(
"INSERT INTO {} ({}, {}, {}) VALUES (?1, ?2, ?3);",
*DAO_DAOS_TABLE, DAO_DAOS_COL_BULLA, DAO_DAOS_COL_NAME, DAO_DAOS_COL_PARAMS,
);
if let Err(e) = self.wallet.exec_sql(
&query,
rusqlite::params![
serialize_async(¶ms.dao.to_bulla()).await,
name,
serialize_async(¶ms).await,
],
) {
return Err(Error::DatabaseError(format!("[import_dao] DAO insert failed: {e:?}")))
};
Ok(())
}
pub async fn get_dao_by_bulla(&self, bulla: &DaoBulla) -> Result<DaoRecord> {
let row = match self.wallet.query_single(
&DAO_DAOS_TABLE,
&[],
convert_named_params! {(DAO_DAOS_COL_BULLA, serialize_async(bulla).await)},
) {
Ok(r) => r,
Err(e) => {
return Err(Error::DatabaseError(format!(
"[get_dao_by_bulla] DAO retrieval failed: {e:?}"
)))
}
};
self.parse_dao_record(&row).await
}
pub async fn get_dao_by_name(&self, name: &str) -> Result<DaoRecord> {
let row = match self.wallet.query_single(
&DAO_DAOS_TABLE,
&[],
convert_named_params! {(DAO_DAOS_COL_NAME, name)},
) {
Ok(r) => r,
Err(e) => {
return Err(Error::DatabaseError(format!(
"[get_dao_by_name] DAO retrieval failed: {e:?}"
)))
}
};
self.parse_dao_record(&row).await
}
pub async fn dao_list(&self, name: &Option<String>) -> Result<()> {
if let Some(name) = name {
let dao = self.get_dao_by_name(name).await?;
println!("{dao}");
return Ok(());
}
let daos = self.get_daos().await?;
for (i, dao) in daos.iter().enumerate() {
println!("{i}. {}", dao.name);
}
Ok(())
}
pub async fn dao_balance(&self, name: &str) -> Result<HashMap<String, u64>> {
let dao = self.get_dao_by_name(name).await?;
let dao_spend_hook =
FuncRef { contract_id: *DAO_CONTRACT_ID, func_code: DaoFunction::Exec as u8 }
.to_func_id();
let mut coins = self.get_coins(false).await?;
coins.retain(|x| x.0.note.spend_hook == dao_spend_hook);
coins.retain(|x| x.0.note.user_data == dao.bulla().inner());
let mut balmap: HashMap<String, u64> = HashMap::new();
for coin in coins {
let mut value = coin.0.note.value;
if let Some(prev) = balmap.get(&coin.0.note.token_id.to_string()) {
value += prev;
}
balmap.insert(coin.0.note.token_id.to_string(), value);
}
Ok(balmap)
}
pub async fn get_proposals(&self) -> Result<Vec<ProposalRecord>> {
let rows = match self.wallet.query_multiple(&DAO_PROPOSALS_TABLE, &[], &[]) {
Ok(r) => r,
Err(e) => {
return Err(Error::DatabaseError(format!(
"[get_proposals] DAO proposalss retrieval failed: {e:?}"
)))
}
};
let mut daos = Vec::with_capacity(rows.len());
for row in rows {
daos.push(self.parse_dao_proposal(&row).await?);
}
Ok(daos)
}
pub async fn get_dao_proposal_by_bulla(
&self,
bulla: &DaoProposalBulla,
) -> Result<ProposalRecord> {
let row = match self.wallet.query_single(
&DAO_PROPOSALS_TABLE,
&[],
convert_named_params! {(DAO_PROPOSALS_COL_BULLA, serialize_async(bulla).await)},
) {
Ok(r) => r,
Err(e) => {
return Err(Error::DatabaseError(format!(
"[get_dao_proposal_by_bulla] DAO proposal retrieval failed: {e:?}"
)))
}
};
self.parse_dao_proposal(&row).await
}
pub async fn get_dao_proposal_votes(
&self,
proposal: &DaoProposalBulla,
) -> Result<Vec<VoteRecord>> {
let rows = match self.wallet.query_multiple(
&DAO_VOTES_TABLE,
&[],
convert_named_params! {(DAO_VOTES_COL_PROPOSAL_BULLA, serialize_async(proposal).await)},
) {
Ok(r) => r,
Err(e) => {
return Err(Error::DatabaseError(format!(
"[get_dao_proposal_votes] Votes retrieval failed: {e:?}"
)))
}
};
let mut votes = Vec::with_capacity(rows.len());
for row in rows {
let Value::Integer(id) = row[0] else {
return Err(Error::ParseFailed("[get_dao_proposal_votes] ID parsing failed"))
};
let Ok(id) = u64::try_from(id) else {
return Err(Error::ParseFailed("[get_dao_proposal_votes] ID parsing failed"))
};
let Value::Blob(ref proposal_bytes) = row[1] else {
return Err(Error::ParseFailed(
"[get_dao_proposal_votes] Proposal bytes bytes parsing failed",
))
};
let proposal = deserialize_async(proposal_bytes).await?;
let Value::Integer(vote_option) = row[2] else {
return Err(Error::ParseFailed(
"[get_dao_proposal_votes] Vote option parsing failed",
))
};
let Ok(vote_option) = u32::try_from(vote_option) else {
return Err(Error::ParseFailed(
"[get_dao_proposal_votes] Vote option parsing failed",
))
};
let vote_option = vote_option != 0;
let Value::Blob(ref yes_vote_blind_bytes) = row[3] else {
return Err(Error::ParseFailed(
"[get_dao_proposal_votes] Yes vote blind bytes parsing failed",
))
};
let yes_vote_blind = deserialize_async(yes_vote_blind_bytes).await?;
let Value::Blob(ref all_vote_value_bytes) = row[4] else {
return Err(Error::ParseFailed(
"[get_dao_proposal_votes] All vote value bytes parsing failed",
))
};
let all_vote_value = deserialize_async(all_vote_value_bytes).await?;
let Value::Blob(ref all_vote_blind_bytes) = row[5] else {
return Err(Error::ParseFailed(
"[get_dao_proposal_votes] All vote blind bytes parsing failed",
))
};
let all_vote_blind = deserialize_async(all_vote_blind_bytes).await?;
let Value::Blob(ref tx_hash_bytes) = row[6] else {
return Err(Error::ParseFailed(
"[get_dao_proposal_votes] Transaction hash bytes parsing failed",
))
};
let tx_hash = deserialize_async(tx_hash_bytes).await?;
let Value::Integer(call_index) = row[7] else {
return Err(Error::ParseFailed("[get_dao_proposal_votes] Call index parsing failed"))
};
let Ok(call_index) = u8::try_from(call_index) else {
return Err(Error::ParseFailed("[get_dao_proposal_votes] Call index parsing failed"))
};
let Value::Blob(ref nullifiers_bytes) = row[8] else {
return Err(Error::ParseFailed(
"[get_dao_proposal_votes] Nullifiers bytes parsing failed",
))
};
let nullifiers = deserialize_async(nullifiers_bytes).await?;
let vote = VoteRecord {
id,
proposal,
vote_option,
yes_vote_blind,
all_vote_value,
all_vote_blind,
tx_hash,
call_index,
nullifiers,
};
votes.push(vote);
}
Ok(votes)
}
pub async fn dao_mint(&self, name: &str) -> Result<Transaction> {
let dao = self.get_dao_by_name(name).await?;
if dao.tx_hash.is_some() {
return Err(Error::Custom(
"[dao_mint] This DAO seems to have already been minted on-chain".to_string(),
))
}
let zkas_bins = self.lookup_zkas(&MONEY_CONTRACT_ID).await?;
let Some(fee_zkbin) = zkas_bins.iter().find(|x| x.0 == MONEY_CONTRACT_ZKAS_FEE_NS_V1)
else {
return Err(Error::Custom("Fee circuit not found".to_string()))
};
let fee_zkbin = ZkBinary::decode(&fee_zkbin.1)?;
let fee_circuit = ZkCircuit::new(empty_witnesses(&fee_zkbin)?, &fee_zkbin);
let fee_pk = ProvingKey::build(fee_zkbin.k, &fee_circuit);
let zkas_bins = self.lookup_zkas(&DAO_CONTRACT_ID).await?;
let Some(dao_mint_zkbin) = zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_DAO_MINT_NS)
else {
return Err(Error::DatabaseError("[dao_mint] DAO Mint circuit not found".to_string()))
};
let dao_mint_zkbin = ZkBinary::decode(&dao_mint_zkbin.1)?;
let dao_mint_circuit = ZkCircuit::new(empty_witnesses(&dao_mint_zkbin)?, &dao_mint_zkbin);
let dao_mint_pk = ProvingKey::build(dao_mint_zkbin.k, &dao_mint_circuit);
let (params, proofs) =
make_mint_call(&dao.params.dao, &dao.params.secret_key, &dao_mint_zkbin, &dao_mint_pk)?;
let mut data = vec![DaoFunction::Mint as u8];
params.encode_async(&mut data).await?;
let call = ContractCall { contract_id: *DAO_CONTRACT_ID, data };
let mut tx_builder = TransactionBuilder::new(ContractCallLeaf { call, proofs }, vec![])?;
let mut tx = tx_builder.build()?;
let sigs = tx.create_sigs(&[dao.params.secret_key])?;
tx.signatures.push(sigs);
let tree = self.get_money_tree().await?;
let (fee_call, fee_proofs, fee_secrets) =
self.append_fee_call(&tx, &tree, &fee_pk, &fee_zkbin, None).await?;
tx_builder.append(ContractCallLeaf { call: fee_call, proofs: fee_proofs }, vec![])?;
let mut tx = tx_builder.build()?;
let sigs = tx.create_sigs(&[dao.params.secret_key])?;
tx.signatures.push(sigs);
let sigs = tx.create_sigs(&fee_secrets)?;
tx.signatures.push(sigs);
Ok(tx)
}
#[allow(clippy::too_many_arguments)]
pub async fn dao_propose_transfer(
&self,
name: &str,
duration_blockwindows: u64,
amount: &str,
token_id: TokenId,
recipient: PublicKey,
spend_hook: Option<FuncId>,
user_data: Option<pallas::Base>,
) -> Result<ProposalRecord> {
let dao = self.get_dao_by_name(name).await?;
if dao.leaf_position.is_none() || dao.tx_hash.is_none() || dao.call_index.is_none() {
return Err(Error::Custom(
"[dao_propose_transfer] DAO seems to not have been deployed yet".to_string(),
))
}
let dao_spend_hook =
FuncRef { contract_id: *DAO_CONTRACT_ID, func_code: DaoFunction::Exec as u8 }
.to_func_id();
let dao_bulla = dao.bulla();
let dao_owncoins =
self.get_contract_token_coins(&token_id, &dao_spend_hook, &dao_bulla.inner()).await?;
if dao_owncoins.is_empty() {
return Err(Error::Custom(format!(
"[dao_propose_transfer] Did not find any {token_id} unspent coins owned by this DAO"
)))
}
let amount = decode_base10(amount, BALANCE_BASE10_DECIMALS, false)?;
if dao_owncoins.iter().map(|x| x.note.value).sum::<u64>() < amount {
return Err(Error::Custom(format!(
"[dao_propose_transfer] Not enough DAO balance for token ID: {token_id}",
)))
}
let proposal_coinattrs = CoinAttributes {
public_key: recipient,
value: amount,
token_id,
spend_hook: spend_hook.unwrap_or(FuncId::none()),
user_data: user_data.unwrap_or(pallas::Base::ZERO),
blind: Blind::random(&mut OsRng),
};
let proposal_coins = vec![proposal_coinattrs.to_coin()];
let mut proposal_data = vec![];
proposal_coins.encode_async(&mut proposal_data).await?;
let auth_calls = vec![
DaoAuthCall {
contract_id: *DAO_CONTRACT_ID,
function_code: DaoFunction::AuthMoneyTransfer as u8,
auth_data: proposal_data,
},
DaoAuthCall {
contract_id: *MONEY_CONTRACT_ID,
function_code: MoneyFunction::TransferV1 as u8,
auth_data: vec![],
},
];
let next_block_height = self.get_next_block_height().await?;
let block_target = self.get_block_target().await?;
let creation_blockwindow = blockwindow(next_block_height, block_target);
let proposal = DaoProposal {
auth_calls,
creation_blockwindow,
duration_blockwindows,
user_data: user_data.unwrap_or(pallas::Base::ZERO),
dao_bulla,
blind: Blind::random(&mut OsRng),
};
let proposal_record = ProposalRecord {
proposal,
data: Some(serialize_async(&proposal_coinattrs).await),
leaf_position: None,
money_snapshot_tree: None,
nullifiers_smt_snapshot: None,
tx_hash: None,
call_index: None,
exec_tx_hash: None,
};
if let Err(e) = self.put_dao_proposal(&proposal_record).await {
return Err(Error::DatabaseError(format!(
"[dao_propose_transfer] Put DAO proposal failed: {e:?}"
)))
}
Ok(proposal_record)
}
pub async fn dao_transfer_proposal_tx(&self, proposal: &ProposalRecord) -> Result<Transaction> {
if proposal.data.is_none() {
return Err(Error::Custom(
"[dao_transfer_proposal_tx] Proposal plainext data is empty".to_string(),
))
}
let proposal_coinattrs: CoinAttributes =
deserialize_async(proposal.data.as_ref().unwrap()).await?;
let Ok(dao) = self.get_dao_by_bulla(&proposal.proposal.dao_bulla).await else {
return Err(Error::Custom(format!(
"[dao_transfer_proposal_tx] DAO {} was not found",
proposal.proposal.dao_bulla
)))
};
if dao.leaf_position.is_none() || dao.tx_hash.is_none() || dao.call_index.is_none() {
return Err(Error::Custom(
"[dao_transfer_proposal_tx] DAO seems to not have been deployed yet".to_string(),
))
}
let dao_spend_hook =
FuncRef { contract_id: *DAO_CONTRACT_ID, func_code: DaoFunction::Exec as u8 }
.to_func_id();
let dao_owncoins = self
.get_contract_token_coins(
&proposal_coinattrs.token_id,
&dao_spend_hook,
&proposal.proposal.dao_bulla.inner(),
)
.await?;
if dao_owncoins.is_empty() {
return Err(Error::Custom(format!(
"[dao_transfer_proposal_tx] Did not find any {} unspent coins owned by this DAO",
proposal_coinattrs.token_id,
)))
}
if dao_owncoins.iter().map(|x| x.note.value).sum::<u64>() < proposal_coinattrs.value {
return Err(Error::Custom(format!(
"[dao_transfer_proposal_tx] Not enough DAO balance for token ID: {}",
proposal_coinattrs.token_id,
)))
}
let gov_owncoins = self.get_token_coins(&dao.params.dao.gov_token_id).await?;
if gov_owncoins.is_empty() {
return Err(Error::Custom(format!(
"[dao_transfer_proposal_tx] Did not find any governance {} coins in wallet",
dao.params.dao.gov_token_id
)))
}
let mut total_value = 0;
let mut gov_owncoins_to_use = vec![];
for gov_owncoin in gov_owncoins {
if total_value >= dao.params.dao.proposer_limit {
break
}
total_value += gov_owncoin.note.value;
gov_owncoins_to_use.push(gov_owncoin);
}
if total_value < dao.params.dao.proposer_limit {
return Err(Error::Custom(format!(
"[dao_transfer_proposal_tx] Not enough gov token {} balance to propose",
dao.params.dao.gov_token_id
)))
}
let zkas_bins = self.lookup_zkas(&MONEY_CONTRACT_ID).await?;
let Some(fee_zkbin) = zkas_bins.iter().find(|x| x.0 == MONEY_CONTRACT_ZKAS_FEE_NS_V1)
else {
return Err(Error::Custom(
"[dao_transfer_proposal_tx] Fee circuit not found".to_string(),
))
};
let fee_zkbin = ZkBinary::decode(&fee_zkbin.1)?;
let fee_circuit = ZkCircuit::new(empty_witnesses(&fee_zkbin)?, &fee_zkbin);
let fee_pk = ProvingKey::build(fee_zkbin.k, &fee_circuit);
let zkas_bins = self.lookup_zkas(&DAO_CONTRACT_ID).await?;
let Some(propose_burn_zkbin) =
zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_DAO_PROPOSE_INPUT_NS)
else {
return Err(Error::Custom(
"[dao_transfer_proposal_tx] Propose Burn circuit not found".to_string(),
))
};
let Some(propose_main_zkbin) =
zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS)
else {
return Err(Error::Custom(
"[dao_transfer_proposal_tx] Propose Main circuit not found".to_string(),
))
};
let propose_burn_zkbin = ZkBinary::decode(&propose_burn_zkbin.1)?;
let propose_main_zkbin = ZkBinary::decode(&propose_main_zkbin.1)?;
let propose_burn_circuit =
ZkCircuit::new(empty_witnesses(&propose_burn_zkbin)?, &propose_burn_zkbin);
let propose_main_circuit =
ZkCircuit::new(empty_witnesses(&propose_main_zkbin)?, &propose_main_zkbin);
let propose_burn_pk = ProvingKey::build(propose_burn_zkbin.k, &propose_burn_circuit);
let propose_main_pk = ProvingKey::build(propose_main_zkbin.k, &propose_main_circuit);
let money_merkle_tree = self.get_money_tree().await?;
let mut inputs = Vec::with_capacity(gov_owncoins_to_use.len());
for gov_owncoin in gov_owncoins_to_use {
let input = DaoProposeStakeInput {
secret: gov_owncoin.secret,
note: gov_owncoin.note.clone(),
leaf_position: gov_owncoin.leaf_position,
merkle_path: money_merkle_tree.witness(gov_owncoin.leaf_position, 0).unwrap(),
};
inputs.push(input);
}
let signature_secret = SecretKey::random(&mut OsRng);
let (daos_tree, _) = self.get_dao_trees().await?;
let (dao_merkle_path, dao_merkle_root) = {
let root = daos_tree.root(0).unwrap();
let leaf_pos = dao.leaf_position.unwrap();
let dao_merkle_path = daos_tree.witness(leaf_pos, 0).unwrap();
(dao_merkle_path, root)
};
let store = WalletStorage::new(
&self.wallet,
&MONEY_SMT_TABLE,
MONEY_SMT_COL_KEY,
MONEY_SMT_COL_VALUE,
);
let money_null_smt = WalletSmt::new(store, PoseidonFp::new(), &EMPTY_NODES_FP);
let call = DaoProposeCall {
money_null_smt: &money_null_smt,
inputs,
proposal: proposal.proposal.clone(),
dao: dao.params.dao,
dao_leaf_position: dao.leaf_position.unwrap(),
dao_merkle_path,
dao_merkle_root,
signature_secret,
};
let (params, proofs) = call.make(
&propose_burn_zkbin,
&propose_burn_pk,
&propose_main_zkbin,
&propose_main_pk,
)?;
let mut data = vec![DaoFunction::Propose as u8];
params.encode_async(&mut data).await?;
let call = ContractCall { contract_id: *DAO_CONTRACT_ID, data };
let mut tx_builder = TransactionBuilder::new(ContractCallLeaf { call, proofs }, vec![])?;
let mut tx = tx_builder.build()?;
let sigs = tx.create_sigs(&[signature_secret])?;
tx.signatures = vec![sigs];
let tree = self.get_money_tree().await?;
let (fee_call, fee_proofs, fee_secrets) =
self.append_fee_call(&tx, &tree, &fee_pk, &fee_zkbin, None).await?;
tx_builder.append(ContractCallLeaf { call: fee_call, proofs: fee_proofs }, vec![])?;
let mut tx = tx_builder.build()?;
let sigs = tx.create_sigs(&[signature_secret])?;
tx.signatures.push(sigs);
let sigs = tx.create_sigs(&fee_secrets)?;
tx.signatures.push(sigs);
Ok(tx)
}
pub async fn dao_vote(
&self,
proposal_bulla: &DaoProposalBulla,
vote_option: bool,
weight: Option<u64>,
) -> Result<Transaction> {
let Ok(proposal) = self.get_dao_proposal_by_bulla(proposal_bulla).await else {
return Err(Error::Custom(format!("[dao_vote] Proposal {proposal_bulla} was not found")))
};
if proposal.leaf_position.is_none() ||
proposal.money_snapshot_tree.is_none() ||
proposal.nullifiers_smt_snapshot.is_none() ||
proposal.tx_hash.is_none() ||
proposal.call_index.is_none()
{
return Err(Error::Custom(
"[dao_vote] Proposal seems to not have been deployed yet".to_string(),
))
}
if let Some(exec_tx_hash) = proposal.exec_tx_hash {
return Err(Error::Custom(format!(
"[dao_vote] Proposal was executed on transaction: {exec_tx_hash}"
)))
}
if proposal.data.is_none() {
return Err(Error::Custom("[dao_vote] Proposal plainext data is empty".to_string()))
}
let Ok(dao) = self.get_dao_by_bulla(&proposal.proposal.dao_bulla).await else {
return Err(Error::Custom(format!(
"[dao_vote] DAO {} was not found",
proposal.proposal.dao_bulla
)))
};
if dao.leaf_position.is_none() || dao.tx_hash.is_none() || dao.call_index.is_none() {
return Err(Error::Custom(
"[dao_vote] DAO seems to not have been deployed yet".to_string(),
))
}
let votes = self.get_dao_proposal_votes(proposal_bulla).await?;
let mut votes_nullifiers = vec![];
for vote in votes {
for nullifier in vote.nullifiers {
if !votes_nullifiers.contains(&nullifier) {
votes_nullifiers.push(nullifier);
}
}
}
let gov_owncoins = self.get_token_coins(&dao.params.dao.gov_token_id).await?;
if gov_owncoins.is_empty() {
return Err(Error::Custom(format!(
"[dao_vote] Did not find any governance {} coins in wallet",
dao.params.dao.gov_token_id
)))
}
let gov_owncoins_to_use = match weight {
Some(_weight) => {
return Err(Error::Custom(
"[dao_vote] Fractional vote weight not supported yet".to_string(),
))
}
None => gov_owncoins,
};
let zkas_bins = self.lookup_zkas(&MONEY_CONTRACT_ID).await?;
let Some(fee_zkbin) = zkas_bins.iter().find(|x| x.0 == MONEY_CONTRACT_ZKAS_FEE_NS_V1)
else {
return Err(Error::Custom("[dao_vote] Fee circuit not found".to_string()))
};
let fee_zkbin = ZkBinary::decode(&fee_zkbin.1)?;
let fee_circuit = ZkCircuit::new(empty_witnesses(&fee_zkbin)?, &fee_zkbin);
let fee_pk = ProvingKey::build(fee_zkbin.k, &fee_circuit);
let zkas_bins = self.lookup_zkas(&DAO_CONTRACT_ID).await?;
let Some(dao_vote_burn_zkbin) =
zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_DAO_VOTE_INPUT_NS)
else {
return Err(Error::Custom("[dao_vote] DAO Vote Burn circuit not found".to_string()))
};
let Some(dao_vote_main_zkbin) =
zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS)
else {
return Err(Error::Custom("[dao_vote] DAO Vote Main circuit not found".to_string()))
};
let dao_vote_burn_zkbin = ZkBinary::decode(&dao_vote_burn_zkbin.1)?;
let dao_vote_main_zkbin = ZkBinary::decode(&dao_vote_main_zkbin.1)?;
let dao_vote_burn_circuit =
ZkCircuit::new(empty_witnesses(&dao_vote_burn_zkbin)?, &dao_vote_burn_zkbin);
let dao_vote_main_circuit =
ZkCircuit::new(empty_witnesses(&dao_vote_main_zkbin)?, &dao_vote_main_zkbin);
let dao_vote_burn_pk = ProvingKey::build(dao_vote_burn_zkbin.k, &dao_vote_burn_circuit);
let dao_vote_main_pk = ProvingKey::build(dao_vote_main_zkbin.k, &dao_vote_main_circuit);
let signature_secret = SecretKey::random(&mut OsRng);
let mut inputs = Vec::with_capacity(gov_owncoins_to_use.len());
for gov_owncoin in gov_owncoins_to_use {
let nullifier = poseidon_hash([gov_owncoin.secret.inner(), gov_owncoin.coin.inner()]);
let vote_nullifier =
poseidon_hash([nullifier, gov_owncoin.secret.inner(), proposal_bulla.inner()]);
if votes_nullifiers.contains(&vote_nullifier.into()) {
return Err(Error::Custom("[dao_vote] Duplicate input nullifier found".to_string()))
};
let input = DaoVoteInput {
secret: gov_owncoin.secret,
note: gov_owncoin.note.clone(),
leaf_position: gov_owncoin.leaf_position,
merkle_path: proposal
.money_snapshot_tree
.as_ref()
.unwrap()
.witness(gov_owncoin.leaf_position, 0)
.unwrap(),
signature_secret,
};
inputs.push(input);
}
let next_block_height = self.get_next_block_height().await?;
let block_target = self.get_block_target().await?;
let current_blockwindow = blockwindow(next_block_height, block_target);
let store = MemoryStorageFp { tree: proposal.nullifiers_smt_snapshot.unwrap() };
let money_null_smt = SmtMemoryFp::new(store, PoseidonFp::new(), &EMPTY_NODES_FP);
let call = DaoVoteCall {
money_null_smt: &money_null_smt,
inputs,
vote_option,
proposal: proposal.proposal.clone(),
dao: dao.params.dao.clone(),
dao_keypair: dao.keypair(),
current_blockwindow,
};
let (params, proofs) = call.make(
&dao_vote_burn_zkbin,
&dao_vote_burn_pk,
&dao_vote_main_zkbin,
&dao_vote_main_pk,
)?;
let mut data = vec![DaoFunction::Vote as u8];
params.encode_async(&mut data).await?;
let call = ContractCall { contract_id: *DAO_CONTRACT_ID, data };
let mut tx_builder = TransactionBuilder::new(ContractCallLeaf { call, proofs }, vec![])?;
let mut tx = tx_builder.build()?;
let sigs = tx.create_sigs(&[signature_secret])?;
tx.signatures = vec![sigs];
let tree = self.get_money_tree().await?;
let (fee_call, fee_proofs, fee_secrets) =
self.append_fee_call(&tx, &tree, &fee_pk, &fee_zkbin, None).await?;
tx_builder.append(ContractCallLeaf { call: fee_call, proofs: fee_proofs }, vec![])?;
let mut tx = tx_builder.build()?;
let sigs = tx.create_sigs(&[signature_secret])?;
tx.signatures.push(sigs);
let sigs = tx.create_sigs(&fee_secrets)?;
tx.signatures.push(sigs);
Ok(tx)
}
pub async fn dao_exec_transfer(&self, proposal: &ProposalRecord) -> Result<Transaction> {
if proposal.leaf_position.is_none() ||
proposal.money_snapshot_tree.is_none() ||
proposal.nullifiers_smt_snapshot.is_none() ||
proposal.tx_hash.is_none() ||
proposal.call_index.is_none()
{
return Err(Error::Custom(
"[dao_exec_transfer] Proposal seems to not have been deployed yet".to_string(),
))
}
if let Some(exec_tx_hash) = proposal.exec_tx_hash {
return Err(Error::Custom(format!(
"[dao_exec_transfer] Proposal was executed on transaction: {exec_tx_hash}"
)))
}
if proposal.data.is_none() {
return Err(Error::Custom(
"[dao_exec_transfer] Proposal plainext data is empty".to_string(),
))
}
let proposal_coinattrs: CoinAttributes =
deserialize_async(proposal.data.as_ref().unwrap()).await?;
let Ok(dao) = self.get_dao_by_bulla(&proposal.proposal.dao_bulla).await else {
return Err(Error::Custom(format!(
"[dao_exec_transfer] DAO {} was not found",
proposal.proposal.dao_bulla
)))
};
if dao.leaf_position.is_none() || dao.tx_hash.is_none() || dao.call_index.is_none() {
return Err(Error::Custom(
"[dao_exec_transfer] DAO seems to not have been deployed yet".to_string(),
))
}
let votes = self.get_dao_proposal_votes(&proposal.bulla()).await?;
let mut yes_vote_value = 0;
let mut yes_vote_blind = Blind::ZERO;
let mut all_vote_value = 0;
let mut all_vote_blind = Blind::ZERO;
for vote in votes {
if vote.vote_option {
yes_vote_value += vote.all_vote_value;
};
yes_vote_blind += vote.yes_vote_blind;
all_vote_value += vote.all_vote_value;
all_vote_blind += vote.all_vote_blind;
}
let approval_ratio = (yes_vote_value as f64 * 100.0) / all_vote_value as f64;
if all_vote_value < dao.params.dao.quorum ||
approval_ratio <
(dao.params.dao.approval_ratio_quot / dao.params.dao.approval_ratio_base)
as f64
{
return Err(Error::Custom(
"[dao_exec_transfer] Proposal is not approved yet".to_string(),
))
};
let dao_spend_hook =
FuncRef { contract_id: *DAO_CONTRACT_ID, func_code: DaoFunction::Exec as u8 }
.to_func_id();
let dao_owncoins = self
.get_contract_token_coins(
&proposal_coinattrs.token_id,
&dao_spend_hook,
&proposal.proposal.dao_bulla.inner(),
)
.await?;
if dao_owncoins.is_empty() {
return Err(Error::Custom(format!(
"[dao_exec_transfer] Did not find any {} unspent coins owned by this DAO",
proposal_coinattrs.token_id,
)))
}
if dao_owncoins.iter().map(|x| x.note.value).sum::<u64>() < proposal_coinattrs.value {
return Err(Error::Custom(format!(
"[dao_exec_transfer] Not enough DAO balance for token ID: {}",
proposal_coinattrs.token_id,
)))
}
let (spent_coins, change_value) = select_coins(dao_owncoins, proposal_coinattrs.value)?;
let zkas_bins = self.lookup_zkas(&MONEY_CONTRACT_ID).await?;
let Some(mint_zkbin) = zkas_bins.iter().find(|x| x.0 == MONEY_CONTRACT_ZKAS_MINT_NS_V1)
else {
return Err(Error::Custom("Mint circuit not found".to_string()))
};
let Some(burn_zkbin) = zkas_bins.iter().find(|x| x.0 == MONEY_CONTRACT_ZKAS_BURN_NS_V1)
else {
return Err(Error::Custom("Burn circuit not found".to_string()))
};
let Some(fee_zkbin) = zkas_bins.iter().find(|x| x.0 == MONEY_CONTRACT_ZKAS_FEE_NS_V1)
else {
return Err(Error::Custom("Fee circuit not found".to_string()))
};
let mint_zkbin = ZkBinary::decode(&mint_zkbin.1)?;
let burn_zkbin = ZkBinary::decode(&burn_zkbin.1)?;
let fee_zkbin = ZkBinary::decode(&fee_zkbin.1)?;
let mint_circuit = ZkCircuit::new(empty_witnesses(&mint_zkbin)?, &mint_zkbin);
let burn_circuit = ZkCircuit::new(empty_witnesses(&burn_zkbin)?, &burn_zkbin);
let fee_circuit = ZkCircuit::new(empty_witnesses(&fee_zkbin)?, &fee_zkbin);
let mint_pk = ProvingKey::build(mint_zkbin.k, &mint_circuit);
let burn_pk = ProvingKey::build(burn_zkbin.k, &burn_circuit);
let fee_pk = ProvingKey::build(fee_zkbin.k, &fee_circuit);
let zkas_bins = self.lookup_zkas(&DAO_CONTRACT_ID).await?;
let Some(dao_exec_zkbin) = zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_DAO_EXEC_NS)
else {
return Err(Error::Custom("[dao_exec_transfer] DAO Exec circuit not found".to_string()))
};
let Some(dao_auth_transfer_zkbin) =
zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS)
else {
return Err(Error::Custom(
"[dao_exec_transfer] DAO AuthTransfer circuit not found".to_string(),
))
};
let Some(dao_auth_transfer_enc_coin_zkbin) =
zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_ENC_COIN_NS)
else {
return Err(Error::Custom(
"[dao_exec_transfer] DAO AuthTransferEncCoin circuit not found".to_string(),
))
};
let dao_exec_zkbin = ZkBinary::decode(&dao_exec_zkbin.1)?;
let dao_auth_transfer_zkbin = ZkBinary::decode(&dao_auth_transfer_zkbin.1)?;
let dao_auth_transfer_enc_coin_zkbin =
ZkBinary::decode(&dao_auth_transfer_enc_coin_zkbin.1)?;
let dao_exec_circuit = ZkCircuit::new(empty_witnesses(&dao_exec_zkbin)?, &dao_exec_zkbin);
let dao_auth_transfer_circuit =
ZkCircuit::new(empty_witnesses(&dao_auth_transfer_zkbin)?, &dao_auth_transfer_zkbin);
let dao_auth_transfer_enc_coin_circuit = ZkCircuit::new(
empty_witnesses(&dao_auth_transfer_enc_coin_zkbin)?,
&dao_auth_transfer_enc_coin_zkbin,
);
let dao_exec_pk = ProvingKey::build(dao_exec_zkbin.k, &dao_exec_circuit);
let dao_auth_transfer_pk =
ProvingKey::build(dao_auth_transfer_zkbin.k, &dao_auth_transfer_circuit);
let dao_auth_transfer_enc_coin_pk = ProvingKey::build(
dao_auth_transfer_enc_coin_zkbin.k,
&dao_auth_transfer_enc_coin_circuit,
);
let tree = self.get_money_tree().await?;
let input_user_data_blind = Blind::random(&mut OsRng);
let mut inputs = vec![];
for coin in &spent_coins {
inputs.push(TransferCallInput {
coin: coin.clone(),
merkle_path: tree.witness(coin.leaf_position, 0).unwrap(),
user_data_blind: input_user_data_blind,
});
}
let mut outputs = vec![];
outputs.push(proposal_coinattrs.clone());
let dao_coin_attrs = CoinAttributes {
public_key: dao.keypair().public,
value: change_value,
token_id: proposal_coinattrs.token_id,
spend_hook: dao_spend_hook,
user_data: proposal.proposal.dao_bulla.inner(),
blind: Blind::random(&mut OsRng),
};
outputs.push(dao_coin_attrs.clone());
let transfer_builder = TransferCallBuilder {
clear_inputs: vec![],
inputs,
outputs,
mint_zkbin: mint_zkbin.clone(),
mint_pk: mint_pk.clone(),
burn_zkbin: burn_zkbin.clone(),
burn_pk: burn_pk.clone(),
};
let (transfer_params, transfer_secrets) = transfer_builder.build()?;
let mut data = vec![MoneyFunction::TransferV1 as u8];
transfer_params.encode_async(&mut data).await?;
let transfer_call = ContractCall { contract_id: *MONEY_CONTRACT_ID, data };
let mut input_value = 0;
let mut input_value_blind = Blind::ZERO;
for (input, blind) in spent_coins.iter().zip(transfer_secrets.input_value_blinds.iter()) {
input_value += input.note.value;
input_value_blind += *blind;
}
let exec_signature_secret = SecretKey::random(&mut OsRng);
let exec_builder = DaoExecCall {
proposal: proposal.proposal.clone(),
dao: dao.params.dao.clone(),
yes_vote_value,
all_vote_value,
yes_vote_blind,
all_vote_blind,
input_value,
input_value_blind,
input_user_data_blind,
hook_dao_exec: DAO_CONTRACT_ID.inner(),
signature_secret: exec_signature_secret,
};
let (exec_params, exec_proofs) = exec_builder.make(&dao_exec_zkbin, &dao_exec_pk)?;
let mut data = vec![DaoFunction::Exec as u8];
exec_params.encode_async(&mut data).await?;
let exec_call = ContractCall { contract_id: *DAO_CONTRACT_ID, data };
let auth_transfer_builder = DaoAuthMoneyTransferCall {
proposal: proposal.proposal.clone(),
proposal_coinattrs: vec![proposal_coinattrs],
dao: dao.params.dao.clone(),
input_user_data_blind,
dao_coin_attrs,
};
let (auth_transfer_params, auth_transfer_proofs) = auth_transfer_builder.make(
&dao_auth_transfer_zkbin,
&dao_auth_transfer_pk,
&dao_auth_transfer_enc_coin_zkbin,
&dao_auth_transfer_enc_coin_pk,
)?;
let mut data = vec![DaoFunction::AuthMoneyTransfer as u8];
auth_transfer_params.encode_async(&mut data).await?;
let auth_transfer_call = ContractCall { contract_id: *DAO_CONTRACT_ID, data };
let mut tx_builder = TransactionBuilder::new(
ContractCallLeaf { call: exec_call, proofs: exec_proofs },
vec![
DarkTree::new(
ContractCallLeaf { call: auth_transfer_call, proofs: auth_transfer_proofs },
vec![],
None,
None,
),
DarkTree::new(
ContractCallLeaf { call: transfer_call, proofs: transfer_secrets.proofs },
vec![],
None,
None,
),
],
)?;
let mut tx = tx_builder.build()?;
let auth_transfer_sigs = tx.create_sigs(&[])?;
let transfer_sigs = tx.create_sigs(&transfer_secrets.signature_secrets)?;
let exec_sigs = tx.create_sigs(&[exec_signature_secret])?;
tx.signatures = vec![auth_transfer_sigs, transfer_sigs, exec_sigs];
let (fee_call, fee_proofs, fee_secrets) =
self.append_fee_call(&tx, &tree, &fee_pk, &fee_zkbin, None).await?;
tx_builder.append(ContractCallLeaf { call: fee_call, proofs: fee_proofs }, vec![])?;
let mut tx = tx_builder.build()?;
let sigs = tx.create_sigs(&[])?;
tx.signatures.push(sigs);
let sigs = tx.create_sigs(&transfer_secrets.signature_secrets)?;
tx.signatures.push(sigs);
let sigs = tx.create_sigs(&[exec_signature_secret])?;
tx.signatures.push(sigs);
let sigs = tx.create_sigs(&fee_secrets)?;
tx.signatures.push(sigs);
Ok(tx)
}
}