contract/dao: simplyfied constants naming scheme

bin/drk/src/dao.rs

@@ -43,11 +43,11 @@ use darkfi_dao_contract::{
         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_EARLY_EXEC_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,
+    DaoFunction, DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_ENC_COIN_NS,
+    DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_NS, DAO_CONTRACT_ZKAS_EARLY_EXEC_NS,
+    DAO_CONTRACT_ZKAS_EXEC_NS, DAO_CONTRACT_ZKAS_MINT_NS, DAO_CONTRACT_ZKAS_PROPOSE_INPUT_NS,
+    DAO_CONTRACT_ZKAS_PROPOSE_MAIN_NS, DAO_CONTRACT_ZKAS_VOTE_INPUT_NS,
+    DAO_CONTRACT_ZKAS_VOTE_MAIN_NS,
 };
 use darkfi_money_contract::{
     client::transfer_v1::{select_coins, TransferCallBuilder, TransferCallInput},
@@ -2140,7 +2140,7 @@ impl Drk {
         // Now we grab the DAO mint
         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)
+        let Some(dao_mint_zkbin) = zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_MINT_NS)
         else {
             return Err(Error::DatabaseError("[dao_mint] DAO Mint circuit not found".to_string()))
         };
@@ -2479,7 +2479,7 @@ impl Drk {
         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)
+            zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_PROPOSE_INPUT_NS)
         else {
             return Err(Error::Custom(
                 "[dao_transfer_proposal_tx] Propose Burn circuit not found".to_string(),
@@ -2487,7 +2487,7 @@ impl Drk {
         };
 
         let Some(propose_main_zkbin) =
-            zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS)
+            zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_PROPOSE_MAIN_NS)
         else {
             return Err(Error::Custom(
                 "[dao_transfer_proposal_tx] Propose Main circuit not found".to_string(),
@@ -2659,7 +2659,7 @@ impl Drk {
         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)
+            zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_PROPOSE_INPUT_NS)
         else {
             return Err(Error::Custom(
                 "[dao_generic_proposal_tx] Propose Burn circuit not found".to_string(),
@@ -2667,7 +2667,7 @@ impl Drk {
         };
 
         let Some(propose_main_zkbin) =
-            zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS)
+            zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_PROPOSE_MAIN_NS)
         else {
             return Err(Error::Custom(
                 "[dao_generic_proposal_tx] Propose Main circuit not found".to_string(),
@@ -2863,13 +2863,13 @@ impl Drk {
         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)
+            zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_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)
+            zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_VOTE_MAIN_NS)
         else {
             return Err(Error::Custom("[dao_vote] DAO Vote Main circuit not found".to_string()))
         };
@@ -3131,11 +3131,10 @@ impl Drk {
         let zkas_bins = self.lookup_zkas(&DAO_CONTRACT_ID).await?;
 
         let (namespace, early_exec_secret_key) = match early {
-            true => (
-                DAO_CONTRACT_ZKAS_DAO_EARLY_EXEC_NS,
-                Some(dao.params.early_exec_secret_key.unwrap()),
-            ),
-            false => (DAO_CONTRACT_ZKAS_DAO_EXEC_NS, None),
+            true => {
+                (DAO_CONTRACT_ZKAS_EARLY_EXEC_NS, Some(dao.params.early_exec_secret_key.unwrap()))
+            }
+            false => (DAO_CONTRACT_ZKAS_EXEC_NS, None),
         };
 
         let Some(dao_exec_zkbin) = zkas_bins.iter().find(|x| x.0 == namespace) else {
@@ -3145,7 +3144,7 @@ impl Drk {
         };
 
         let Some(dao_auth_transfer_zkbin) =
-            zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS)
+            zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_NS)
         else {
             return Err(Error::Custom(
                 "[dao_exec_transfer] DAO AuthTransfer circuit not found".to_string(),
@@ -3153,7 +3152,7 @@ impl Drk {
         };
 
         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)
+            zkas_bins.iter().find(|x| x.0 == DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_ENC_COIN_NS)
         else {
             return Err(Error::Custom(
                 "[dao_exec_transfer] DAO AuthTransferEncCoin circuit not found".to_string(),
@@ -3416,11 +3415,10 @@ impl Drk {
         let zkas_bins = self.lookup_zkas(&DAO_CONTRACT_ID).await?;
 
         let (namespace, early_exec_secret_key) = match early {
-            true => (
-                DAO_CONTRACT_ZKAS_DAO_EARLY_EXEC_NS,
-                Some(dao.params.early_exec_secret_key.unwrap()),
-            ),
-            false => (DAO_CONTRACT_ZKAS_DAO_EXEC_NS, None),
+            true => {
+                (DAO_CONTRACT_ZKAS_EARLY_EXEC_NS, Some(dao.params.early_exec_secret_key.unwrap()))
+            }
+            false => (DAO_CONTRACT_ZKAS_EXEC_NS, None),
         };
 
         let Some(dao_exec_zkbin) = zkas_bins.iter().find(|x| x.0 == namespace) else {

src/contract/dao/src/entrypoint/auth_xfer.rs

@@ -34,8 +34,8 @@ use darkfi_serial::{deserialize, Encodable};
 use crate::{
     error::DaoError,
     model::{DaoAuthCall, DaoAuthMoneyTransferParams, DaoExecParams, VecAuthCallCommit},
-    DaoFunction, DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_ENC_COIN_NS,
-    DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS,
+    DaoFunction, DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_ENC_COIN_NS,
+    DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_NS,
 };
 
 /// `get_metdata` function for `Dao::AuthMoneyTransfer`
@@ -72,7 +72,7 @@ pub(crate) fn dao_authxfer_get_metadata(
         let coin = output.coin;
         let (ephem_x, ephem_y) = enc_attrs.ephem_public.xy();
         zk_public_inputs.push((
-            DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_ENC_COIN_NS.to_string(),
+            DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_ENC_COIN_NS.to_string(),
             vec![
                 coin.inner(),
                 ephem_x,
@@ -97,7 +97,7 @@ pub(crate) fn dao_authxfer_get_metadata(
 
     let (ephem_x, ephem_y) = self_params.dao_change_attrs.ephem_public.xy();
     zk_public_inputs.push((
-        DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS.to_string(),
+        DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_NS.to_string(),
         vec![
             exec_params.proposal_bulla.inner(),
             input_user_data_enc,

src/contract/dao/src/entrypoint/exec.rs

@@ -30,8 +30,7 @@ use crate::{
     blockwindow,
     error::DaoError,
     model::{DaoExecParams, DaoExecUpdate, DaoProposalMetadata, VecAuthCallCommit},
-    DAO_CONTRACT_DB_PROPOSAL_BULLAS, DAO_CONTRACT_ZKAS_DAO_EARLY_EXEC_NS,
-    DAO_CONTRACT_ZKAS_DAO_EXEC_NS,
+    DAO_CONTRACT_PROPOSAL_BULLAS_TREE, DAO_CONTRACT_ZKAS_EARLY_EXEC_NS, DAO_CONTRACT_ZKAS_EXEC_NS,
 };
 
 /// `get_metdata` function for `Dao::Exec`
@@ -57,8 +56,8 @@ pub(crate) fn dao_exec_get_metadata(
 
     // Grab proof namespace to use, based on early execution flag
     let proof_namespace = match params.early_exec {
-        true => DAO_CONTRACT_ZKAS_DAO_EARLY_EXEC_NS.to_string(),
-        false => DAO_CONTRACT_ZKAS_DAO_EXEC_NS.to_string(),
+        true => DAO_CONTRACT_ZKAS_EARLY_EXEC_NS.to_string(),
+        false => DAO_CONTRACT_ZKAS_EXEC_NS.to_string(),
     };
 
     zk_public_inputs.push((
@@ -126,7 +125,7 @@ pub(crate) fn dao_exec_process_instruction(
     ///////////////////////////////////////////////////
 
     // Get the ProposalVote from DAO state
-    let proposal_db = wasm::db::db_lookup(cid, DAO_CONTRACT_DB_PROPOSAL_BULLAS)?;
+    let proposal_db = wasm::db::db_lookup(cid, DAO_CONTRACT_PROPOSAL_BULLAS_TREE)?;
     let Some(data) = wasm::db::db_get(proposal_db, &serialize(&params.proposal_bulla))? else {
         msg!("[Dao::Exec] Error: Proposal {:?} not found", params.proposal_bulla);
         return Err(DaoError::ProposalNonexistent.into())
@@ -148,7 +147,7 @@ pub(crate) fn dao_exec_process_instruction(
 /// `process_update` function for `Dao::Exec`
 pub(crate) fn dao_exec_process_update(cid: ContractId, update: DaoExecUpdate) -> ContractResult {
     // Remove proposal from db
-    let proposal_db = wasm::db::db_lookup(cid, DAO_CONTRACT_DB_PROPOSAL_BULLAS)?;
+    let proposal_db = wasm::db::db_lookup(cid, DAO_CONTRACT_PROPOSAL_BULLAS_TREE)?;
     wasm::db::db_del(proposal_db, &serialize(&update.proposal_bulla))?;
 
     Ok(())

src/contract/dao/src/entrypoint/mint.rs

@@ -29,9 +29,8 @@ use darkfi_serial::{deserialize, serialize, Encodable};
 use crate::{
     error::DaoError,
     model::{DaoMintParams, DaoMintUpdate},
-    DAO_CONTRACT_DB_DAO_BULLAS, DAO_CONTRACT_DB_DAO_MERKLE_ROOTS, DAO_CONTRACT_DB_INFO_TREE,
-    DAO_CONTRACT_KEY_DAO_MERKLE_TREE, DAO_CONTRACT_KEY_LATEST_DAO_ROOT,
-    DAO_CONTRACT_ZKAS_DAO_MINT_NS,
+    DAO_CONTRACT_BULLAS_TREE, DAO_CONTRACT_INFO_TREE, DAO_CONTRACT_LATEST_ROOT,
+    DAO_CONTRACT_MERKLE_ROOTS_TREE, DAO_CONTRACT_MERKLE_TREE, DAO_CONTRACT_ZKAS_MINT_NS,
 };
 
 /// `get_metadata` function for `Dao::Mint`
@@ -52,7 +51,7 @@ pub(crate) fn dao_mint_get_metadata(
     let (pub_x, pub_y) = params.dao_pubkey.xy();
 
     zk_public_inputs.push((
-        DAO_CONTRACT_ZKAS_DAO_MINT_NS.to_string(),
+        DAO_CONTRACT_ZKAS_MINT_NS.to_string(),
         vec![pub_x, pub_y, params.dao_bulla.inner()],
     ));
 
@@ -74,7 +73,7 @@ pub(crate) fn dao_mint_process_instruction(
     let params: DaoMintParams = deserialize(&self_.data[1..])?;
 
     // Check the DAO bulla doesn't already exist
-    let bulla_db = wasm::db::db_lookup(cid, DAO_CONTRACT_DB_DAO_BULLAS)?;
+    let bulla_db = wasm::db::db_lookup(cid, DAO_CONTRACT_BULLAS_TREE)?;
     if wasm::db::db_contains_key(bulla_db, &serialize(&params.dao_bulla.inner()))? {
         msg!("[DAO::Mint] Error: DAO already exists {}", params.dao_bulla);
         return Err(DaoError::DaoAlreadyExists.into())
@@ -88,9 +87,9 @@ pub(crate) fn dao_mint_process_instruction(
 /// `process_update` function for `Dao::Mint`
 pub(crate) fn dao_mint_process_update(cid: ContractId, update: DaoMintUpdate) -> ContractResult {
     // Grab all db handles we want to work on
-    let info_db = wasm::db::db_lookup(cid, DAO_CONTRACT_DB_INFO_TREE)?;
-    let bulla_db = wasm::db::db_lookup(cid, DAO_CONTRACT_DB_DAO_BULLAS)?;
-    let roots_db = wasm::db::db_lookup(cid, DAO_CONTRACT_DB_DAO_MERKLE_ROOTS)?;
+    let info_db = wasm::db::db_lookup(cid, DAO_CONTRACT_INFO_TREE)?;
+    let bulla_db = wasm::db::db_lookup(cid, DAO_CONTRACT_BULLAS_TREE)?;
+    let roots_db = wasm::db::db_lookup(cid, DAO_CONTRACT_MERKLE_ROOTS_TREE)?;
 
     wasm::db::db_set(bulla_db, &serialize(&update.dao_bulla), &[])?;
 
@@ -98,8 +97,8 @@ pub(crate) fn dao_mint_process_update(cid: ContractId, update: DaoMintUpdate) ->
     wasm::merkle::merkle_add(
         info_db,
         roots_db,
-        DAO_CONTRACT_KEY_LATEST_DAO_ROOT,
-        DAO_CONTRACT_KEY_DAO_MERKLE_TREE,
+        DAO_CONTRACT_LATEST_ROOT,
+        DAO_CONTRACT_MERKLE_TREE,
         &dao,
     )?;
 

src/contract/dao/src/entrypoint/mod.rs

@@ -28,9 +28,9 @@ use darkfi_serial::{deserialize, serialize, Decodable, Encodable, WriteExt};
 
 use crate::{
     model::{DaoExecUpdate, DaoMintUpdate, DaoProposeUpdate, DaoVoteUpdate},
-    DaoFunction, DAO_CONTRACT_DB_DAO_BULLAS, DAO_CONTRACT_DB_DAO_MERKLE_ROOTS,
-    DAO_CONTRACT_DB_INFO_TREE, DAO_CONTRACT_DB_PROPOSAL_BULLAS, DAO_CONTRACT_DB_VOTE_NULLIFIERS,
-    DAO_CONTRACT_KEY_DAO_MERKLE_TREE, DAO_CONTRACT_KEY_DB_VERSION,
+    DaoFunction, DAO_CONTRACT_BULLAS_TREE, DAO_CONTRACT_DB_VERSION, DAO_CONTRACT_INFO_TREE,
+    DAO_CONTRACT_MERKLE_ROOTS_TREE, DAO_CONTRACT_MERKLE_TREE, DAO_CONTRACT_PROPOSAL_BULLAS_TREE,
+    DAO_CONTRACT_VOTE_NULLIFIERS_TREE,
 };
 
 /// `Dao::Mint` functions
@@ -79,13 +79,13 @@ fn init_contract(cid: ContractId, _ix: &[u8]) -> ContractResult {
     wasm::db::zkas_db_set(&include_bytes!("../../proof/auth-money-transfer-enc-coin.zk.bin")[..])?;
 
     // Set up db for general info
-    let dao_info_db = match wasm::db::db_lookup(cid, DAO_CONTRACT_DB_INFO_TREE) {
+    let dao_info_db = match wasm::db::db_lookup(cid, DAO_CONTRACT_INFO_TREE) {
         Ok(v) => v,
-        Err(_) => wasm::db::db_init(cid, DAO_CONTRACT_DB_INFO_TREE)?,
+        Err(_) => wasm::db::db_init(cid, DAO_CONTRACT_INFO_TREE)?,
     };
 
     // Set up the entries in the header table
-    match wasm::db::db_get(dao_info_db, DAO_CONTRACT_KEY_DAO_MERKLE_TREE)? {
+    match wasm::db::db_get(dao_info_db, DAO_CONTRACT_MERKLE_TREE)? {
         Some(bytes) => {
             // We found some bytes, try to deserialize into a tree.
             // For now, if this doesn't work, we bail.
@@ -101,42 +101,38 @@ fn init_contract(cid: ContractId, _ix: &[u8]) -> ContractResult {
             tree_data.write_u32(0)?;
             tree.encode(&mut tree_data)?;
 
-            wasm::db::db_set(dao_info_db, DAO_CONTRACT_KEY_DAO_MERKLE_TREE, &tree_data)?;
+            wasm::db::db_set(dao_info_db, DAO_CONTRACT_MERKLE_TREE, &tree_data)?;
         }
     }
 
     // Set up db to avoid double creating DAOs
-    let _ = match wasm::db::db_lookup(cid, DAO_CONTRACT_DB_DAO_BULLAS) {
+    let _ = match wasm::db::db_lookup(cid, DAO_CONTRACT_BULLAS_TREE) {
         Ok(v) => v,
-        Err(_) => wasm::db::db_init(cid, DAO_CONTRACT_DB_DAO_BULLAS)?,
+        Err(_) => wasm::db::db_init(cid, DAO_CONTRACT_BULLAS_TREE)?,
     };
 
     // Set up db for DAO bulla Merkle roots
-    let _ = match wasm::db::db_lookup(cid, DAO_CONTRACT_DB_DAO_MERKLE_ROOTS) {
+    let _ = match wasm::db::db_lookup(cid, DAO_CONTRACT_MERKLE_ROOTS_TREE) {
         Ok(v) => v,
-        Err(_) => wasm::db::db_init(cid, DAO_CONTRACT_DB_DAO_MERKLE_ROOTS)?,
+        Err(_) => wasm::db::db_init(cid, DAO_CONTRACT_MERKLE_ROOTS_TREE)?,
     };
 
     // Set up db for proposal votes
     // k: ProposalBulla
     // v: (BlindAggregateVote, bool) (the bool marks if the proposal is finished)
-    let _ = match wasm::db::db_lookup(cid, DAO_CONTRACT_DB_PROPOSAL_BULLAS) {
+    let _ = match wasm::db::db_lookup(cid, DAO_CONTRACT_PROPOSAL_BULLAS_TREE) {
         Ok(v) => v,
-        Err(_) => wasm::db::db_init(cid, DAO_CONTRACT_DB_PROPOSAL_BULLAS)?,
+        Err(_) => wasm::db::db_init(cid, DAO_CONTRACT_PROPOSAL_BULLAS_TREE)?,
     };
 
     // TODO: These nullifiers should exist per-proposal
-    let _ = match wasm::db::db_lookup(cid, DAO_CONTRACT_DB_VOTE_NULLIFIERS) {
+    let _ = match wasm::db::db_lookup(cid, DAO_CONTRACT_VOTE_NULLIFIERS_TREE) {
         Ok(v) => v,
-        Err(_) => wasm::db::db_init(cid, DAO_CONTRACT_DB_VOTE_NULLIFIERS)?,
+        Err(_) => wasm::db::db_init(cid, DAO_CONTRACT_VOTE_NULLIFIERS_TREE)?,
     };
 
     // Update db version
-    wasm::db::db_set(
-        dao_info_db,
-        DAO_CONTRACT_KEY_DB_VERSION,
-        &serialize(&env!("CARGO_PKG_VERSION")),
-    )?;
+    wasm::db::db_set(dao_info_db, DAO_CONTRACT_DB_VERSION, &serialize(&env!("CARGO_PKG_VERSION")))?;
 
     Ok(())
 }

src/contract/dao/src/entrypoint/propose.rs

@@ -36,8 +36,8 @@ use crate::{
     blockwindow,
     error::DaoError,
     model::{DaoBlindAggregateVote, DaoProposalMetadata, DaoProposeParams, DaoProposeUpdate},
-    DAO_CONTRACT_DB_DAO_MERKLE_ROOTS, DAO_CONTRACT_DB_PROPOSAL_BULLAS,
-    DAO_CONTRACT_ZKAS_DAO_PROPOSE_INPUT_NS, DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS,
+    DAO_CONTRACT_MERKLE_ROOTS_TREE, DAO_CONTRACT_PROPOSAL_BULLAS_TREE,
+    DAO_CONTRACT_ZKAS_PROPOSE_INPUT_NS, DAO_CONTRACT_ZKAS_PROPOSE_MAIN_NS,
     PROPOSAL_SNAPSHOT_CUTOFF_LIMIT,
 };
 
@@ -72,7 +72,7 @@ pub(crate) fn dao_propose_get_metadata(
         let (sig_x, sig_y) = input.signature_public.xy();
 
         zk_public_inputs.push((
-            DAO_CONTRACT_ZKAS_DAO_PROPOSE_INPUT_NS.to_string(),
+            DAO_CONTRACT_ZKAS_PROPOSE_INPUT_NS.to_string(),
             vec![
                 input.smt_null_root,
                 *value_coords.x(),
@@ -92,7 +92,7 @@ pub(crate) fn dao_propose_get_metadata(
 
     let total_funds_coords = total_funds_commit.to_affine().coordinates().unwrap();
     zk_public_inputs.push((
-        DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS.to_string(),
+        DAO_CONTRACT_ZKAS_PROPOSE_MAIN_NS.to_string(),
         vec![
             params.token_commit,
             params.dao_merkle_root.inner(),
@@ -182,14 +182,14 @@ pub(crate) fn dao_propose_process_instruction(
     }
 
     // Is the DAO bulla generated in the ZK proof valid
-    let dao_roots_db = wasm::db::db_lookup(cid, DAO_CONTRACT_DB_DAO_MERKLE_ROOTS)?;
+    let dao_roots_db = wasm::db::db_lookup(cid, DAO_CONTRACT_MERKLE_ROOTS_TREE)?;
     if !wasm::db::db_contains_key(dao_roots_db, &serialize(&params.dao_merkle_root))? {
         msg!("[Dao::Propose] Error: Invalid DAO Merkle root: {}", params.dao_merkle_root);
         return Err(DaoError::InvalidDaoMerkleRoot.into())
     }
 
     // Make sure the proposal doesn't already exist
-    let proposal_db = wasm::db::db_lookup(cid, DAO_CONTRACT_DB_PROPOSAL_BULLAS)?;
+    let proposal_db = wasm::db::db_lookup(cid, DAO_CONTRACT_PROPOSAL_BULLAS_TREE)?;
     if wasm::db::db_contains_key(proposal_db, &serialize(&params.proposal_bulla))? {
         msg!("[Dao::Propose] Error: Proposal already exists: {:?}", params.proposal_bulla);
         return Err(DaoError::ProposalAlreadyExists.into())
@@ -227,7 +227,7 @@ pub(crate) fn dao_propose_process_update(
     update: DaoProposeUpdate,
 ) -> ContractResult {
     // Grab all db handles we want to work on
-    let proposal_db = wasm::db::db_lookup(cid, DAO_CONTRACT_DB_PROPOSAL_BULLAS)?;
+    let proposal_db = wasm::db::db_lookup(cid, DAO_CONTRACT_PROPOSAL_BULLAS_TREE)?;
 
     // Build the proposal metadata
     let proposal_metadata = DaoProposalMetadata {

src/contract/dao/src/entrypoint/vote.rs

@@ -30,8 +30,8 @@ use crate::{
     blockwindow,
     error::DaoError,
     model::{DaoProposalMetadata, DaoVoteParams, DaoVoteUpdate},
-    DAO_CONTRACT_DB_PROPOSAL_BULLAS, DAO_CONTRACT_DB_VOTE_NULLIFIERS,
-    DAO_CONTRACT_ZKAS_DAO_VOTE_INPUT_NS, DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS,
+    DAO_CONTRACT_PROPOSAL_BULLAS_TREE, DAO_CONTRACT_VOTE_NULLIFIERS_TREE,
+    DAO_CONTRACT_ZKAS_VOTE_INPUT_NS, DAO_CONTRACT_ZKAS_VOTE_MAIN_NS,
 };
 
 /// `get_metdata` function for `Dao::Vote`
@@ -56,9 +56,8 @@ pub(crate) fn dao_vote_get_metadata(
     // Commitment calculation for all votes
     let mut all_vote_commit = pallas::Point::identity();
 
-    let proposal_votes_db = wasm::db::db_lookup(cid, DAO_CONTRACT_DB_PROPOSAL_BULLAS)?;
-    let Some(data) = wasm::db::db_get(proposal_votes_db, &serialize(&params.proposal_bulla))?
-    else {
+    let proposal_db = wasm::db::db_lookup(cid, DAO_CONTRACT_PROPOSAL_BULLAS_TREE)?;
+    let Some(data) = wasm::db::db_get(proposal_db, &serialize(&params.proposal_bulla))? else {
         msg!("[Dao::Vote] Error: Proposal doesn't exist: {:?}", params.proposal_bulla);
         return Err(DaoError::ProposalNonexistent.into())
     };
@@ -74,7 +73,7 @@ pub(crate) fn dao_vote_get_metadata(
         let (sig_x, sig_y) = input.signature_public.xy();
 
         zk_public_inputs.push((
-            DAO_CONTRACT_ZKAS_DAO_VOTE_INPUT_NS.to_string(),
+            DAO_CONTRACT_ZKAS_VOTE_INPUT_NS.to_string(),
             vec![
                 proposal_metadata.snapshot_nulls,
                 params.proposal_bulla.inner(),
@@ -97,7 +96,7 @@ pub(crate) fn dao_vote_get_metadata(
 
     let (ephem_x, ephem_y) = params.note.ephem_public.xy();
     zk_public_inputs.push((
-        DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS.to_string(),
+        DAO_CONTRACT_ZKAS_VOTE_MAIN_NS.to_string(),
         vec![
             params.token_commit,
             params.proposal_bulla.inner(),
@@ -133,9 +132,8 @@ pub(crate) fn dao_vote_process_instruction(
     let params: DaoVoteParams = deserialize(&self_.data[1..])?;
 
     // Check proposal bulla exists
-    let proposal_votes_db = wasm::db::db_lookup(cid, DAO_CONTRACT_DB_PROPOSAL_BULLAS)?;
-    let Some(data) = wasm::db::db_get(proposal_votes_db, &serialize(&params.proposal_bulla))?
-    else {
+    let proposal_db = wasm::db::db_lookup(cid, DAO_CONTRACT_PROPOSAL_BULLAS_TREE)?;
+    let Some(data) = wasm::db::db_get(proposal_db, &serialize(&params.proposal_bulla))? else {
         msg!("[Dao::Vote] Error: Proposal doesn't exist: {:?}", params.proposal_bulla);
         return Err(DaoError::ProposalNonexistent.into())
     };
@@ -144,7 +142,7 @@ pub(crate) fn dao_vote_process_instruction(
     let mut proposal_metadata: DaoProposalMetadata = deserialize(&data)?;
 
     // Check the Merkle root and nullifiers for the input coins are valid
-    let dao_vote_nullifier_db = wasm::db::db_lookup(cid, DAO_CONTRACT_DB_VOTE_NULLIFIERS)?;
+    let dao_vote_nullifier_db = wasm::db::db_lookup(cid, DAO_CONTRACT_VOTE_NULLIFIERS_TREE)?;
     let mut vote_nullifiers = vec![];
 
     for input in &params.inputs {
@@ -174,19 +172,19 @@ pub(crate) fn dao_vote_process_instruction(
 /// `process_update` function for `Dao::Vote`
 pub(crate) fn dao_vote_process_update(cid: ContractId, update: DaoVoteUpdate) -> ContractResult {
     // Grab all db handles we want to work on
-    let proposal_vote_db = wasm::db::db_lookup(cid, DAO_CONTRACT_DB_PROPOSAL_BULLAS)?;
+    let proposal_db = wasm::db::db_lookup(cid, DAO_CONTRACT_PROPOSAL_BULLAS_TREE)?;
 
     // Perform this code:
     //   total_yes_vote_commit += update.yes_vote_commit
     //   total_all_vote_commit += update.all_vote_commit
     wasm::db::db_set(
-        proposal_vote_db,
+        proposal_db,
         &serialize(&update.proposal_bulla),
         &serialize(&update.proposal_metadata),
     )?;
 
     // We are essentially doing: vote_nulls.append(update_nulls)
-    let dao_vote_nulls_db = wasm::db::db_lookup(cid, DAO_CONTRACT_DB_VOTE_NULLIFIERS)?;
+    let dao_vote_nulls_db = wasm::db::db_lookup(cid, DAO_CONTRACT_VOTE_NULLIFIERS_TREE)?;
 
     for nullifier in update.vote_nullifiers {
         // Uniqueness is enforced for (proposal_bulla, nullifier)

src/contract/dao/src/lib.rs

@@ -61,35 +61,35 @@ pub mod entrypoint;
 pub mod client;
 
 // These are the different sled trees that will be created
-pub const DAO_CONTRACT_DB_INFO_TREE: &str = "dao_info";
-pub const DAO_CONTRACT_DB_DAO_BULLAS: &str = "dao_bullas";
-pub const DAO_CONTRACT_DB_DAO_MERKLE_ROOTS: &str = "dao_roots";
-pub const DAO_CONTRACT_DB_PROPOSAL_BULLAS: &str = "dao_proposals";
-pub const DAO_CONTRACT_DB_VOTE_NULLIFIERS: &str = "dao_vote_nullifiers";
+pub const DAO_CONTRACT_INFO_TREE: &str = "info";
+pub const DAO_CONTRACT_BULLAS_TREE: &str = "bullas";
+pub const DAO_CONTRACT_MERKLE_ROOTS_TREE: &str = "roots";
+pub const DAO_CONTRACT_PROPOSAL_BULLAS_TREE: &str = "proposals";
+pub const DAO_CONTRACT_VOTE_NULLIFIERS_TREE: &str = "vote_nullifiers";
 
 // These are keys inside the info tree
-pub const DAO_CONTRACT_KEY_DB_VERSION: &[u8] = b"db_version";
-pub const DAO_CONTRACT_KEY_DAO_MERKLE_TREE: &[u8] = b"dao_merkle_tree";
-pub const DAO_CONTRACT_KEY_LATEST_DAO_ROOT: &[u8] = b"dao_last_root";
+pub const DAO_CONTRACT_DB_VERSION: &[u8] = b"db_version";
+pub const DAO_CONTRACT_MERKLE_TREE: &[u8] = b"merkle_tree";
+pub const DAO_CONTRACT_LATEST_ROOT: &[u8] = b"last_root";
 
 /// zkas dao mint circuit namespace
-pub const DAO_CONTRACT_ZKAS_DAO_MINT_NS: &str = "Mint";
+pub const DAO_CONTRACT_ZKAS_MINT_NS: &str = "Mint";
 /// zkas dao vote input circuit namespace
-pub const DAO_CONTRACT_ZKAS_DAO_VOTE_INPUT_NS: &str = "VoteInput";
+pub const DAO_CONTRACT_ZKAS_VOTE_INPUT_NS: &str = "VoteInput";
 /// zkas dao vote main circuit namespace
-pub const DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS: &str = "VoteMain";
+pub const DAO_CONTRACT_ZKAS_VOTE_MAIN_NS: &str = "VoteMain";
 /// zkas dao propose input circuit namespace
-pub const DAO_CONTRACT_ZKAS_DAO_PROPOSE_INPUT_NS: &str = "ProposeInput";
+pub const DAO_CONTRACT_ZKAS_PROPOSE_INPUT_NS: &str = "ProposeInput";
 /// zkas dao propose main circuit namespace
-pub const DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS: &str = "ProposeMain";
+pub const DAO_CONTRACT_ZKAS_PROPOSE_MAIN_NS: &str = "ProposeMain";
 /// zkas dao exec circuit namespace
-pub const DAO_CONTRACT_ZKAS_DAO_EXEC_NS: &str = "Exec";
+pub const DAO_CONTRACT_ZKAS_EXEC_NS: &str = "Exec";
 /// zkas dao early exec circuit namespace
-pub const DAO_CONTRACT_ZKAS_DAO_EARLY_EXEC_NS: &str = "EarlyExec";
+pub const DAO_CONTRACT_ZKAS_EARLY_EXEC_NS: &str = "EarlyExec";
 /// zkas dao auth money_transfer circuit namespace
-pub const DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS: &str = "AuthMoneyTransfer";
+pub const DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_NS: &str = "AuthMoneyTransfer";
 /// zkas dao auth money_transfer encrypted coin circuit namespace
-pub const DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_ENC_COIN_NS: &str = "AuthMoneyTransferEncCoin";
+pub const DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_ENC_COIN_NS: &str = "AuthMoneyTransferEncCoin";
 
 /// Not allowed to make proposals using snapshots with block heights older than this depth
 pub const PROPOSAL_SNAPSHOT_CUTOFF_LIMIT: u32 = 100;

src/contract/test-harness/src/dao_exec.rs

@@ -24,9 +24,9 @@ use darkfi_dao_contract::{
     blockwindow,
     client::{DaoAuthMoneyTransferCall, DaoExecCall},
     model::{Dao, DaoProposal},
-    DaoFunction, DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_ENC_COIN_NS,
-    DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS, DAO_CONTRACT_ZKAS_DAO_EARLY_EXEC_NS,
-    DAO_CONTRACT_ZKAS_DAO_EXEC_NS,
+    DaoFunction, DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_ENC_COIN_NS,
+    DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_NS, DAO_CONTRACT_ZKAS_EARLY_EXEC_NS,
+    DAO_CONTRACT_ZKAS_EXEC_NS,
 };
 use darkfi_money_contract::{
     client::{transfer_v1 as xfer, MoneyNote, OwnCoin},
@@ -70,13 +70,13 @@ impl TestHarness {
         let (burn_pk, burn_zkbin) = self.proving_keys.get(MONEY_CONTRACT_ZKAS_BURN_NS_V1).unwrap();
 
         let (dao_exec_pk, dao_exec_zkbin) = match dao_early_exec_secret_key {
-            Some(_) => self.proving_keys.get(DAO_CONTRACT_ZKAS_DAO_EARLY_EXEC_NS).unwrap(),
-            None => self.proving_keys.get(DAO_CONTRACT_ZKAS_DAO_EXEC_NS).unwrap(),
+            Some(_) => self.proving_keys.get(DAO_CONTRACT_ZKAS_EARLY_EXEC_NS).unwrap(),
+            None => self.proving_keys.get(DAO_CONTRACT_ZKAS_EXEC_NS).unwrap(),
         };
         let (dao_auth_xfer_pk, dao_auth_xfer_zkbin) =
-            self.proving_keys.get(DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS).unwrap();
+            self.proving_keys.get(DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_NS).unwrap();
         let (dao_auth_xfer_enc_coin_pk, dao_auth_xfer_enc_coin_zkbin) =
-            self.proving_keys.get(DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_ENC_COIN_NS).unwrap();
+            self.proving_keys.get(DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_ENC_COIN_NS).unwrap();
 
         let input_user_data_blind = Blind::random(&mut OsRng);
         let exec_signature_secret = SecretKey::random(&mut OsRng);
@@ -270,8 +270,8 @@ impl TestHarness {
         let wallet = self.holders.get_mut(holder).unwrap();
 
         let (dao_exec_pk, dao_exec_zkbin) = match dao_early_exec_secret_key {
-            Some(_) => self.proving_keys.get(DAO_CONTRACT_ZKAS_DAO_EARLY_EXEC_NS).unwrap(),
-            None => self.proving_keys.get(DAO_CONTRACT_ZKAS_DAO_EXEC_NS).unwrap(),
+            Some(_) => self.proving_keys.get(DAO_CONTRACT_ZKAS_EARLY_EXEC_NS).unwrap(),
+            None => self.proving_keys.get(DAO_CONTRACT_ZKAS_EXEC_NS).unwrap(),
         };
 
         // Create the exec call

src/contract/test-harness/src/dao_mint.rs

@@ -23,7 +23,7 @@ use darkfi::{
 use darkfi_dao_contract::{
     client::make_mint_call,
     model::{Dao, DaoMintParams},
-    DaoFunction, DAO_CONTRACT_ZKAS_DAO_MINT_NS,
+    DaoFunction, DAO_CONTRACT_ZKAS_MINT_NS,
 };
 use darkfi_money_contract::{
     client::{MoneyNote, OwnCoin},
@@ -57,7 +57,7 @@ impl TestHarness {
         block_height: u32,
     ) -> Result<(Transaction, DaoMintParams, Option<MoneyFeeParamsV1>)> {
         let (dao_mint_pk, dao_mint_zkbin) =
-            self.proving_keys.get(DAO_CONTRACT_ZKAS_DAO_MINT_NS).unwrap();
+            self.proving_keys.get(DAO_CONTRACT_ZKAS_MINT_NS).unwrap();
 
         // Create the call
         let (params, proofs) = make_mint_call(

src/contract/test-harness/src/dao_propose.rs

@@ -24,7 +24,7 @@ use darkfi_dao_contract::{
     blockwindow,
     client::{DaoProposeCall, DaoProposeStakeInput},
     model::{Dao, DaoAuthCall, DaoProposal, DaoProposeParams},
-    DaoFunction, DAO_CONTRACT_ZKAS_DAO_PROPOSE_INPUT_NS, DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS,
+    DaoFunction, DAO_CONTRACT_ZKAS_PROPOSE_INPUT_NS, DAO_CONTRACT_ZKAS_PROPOSE_MAIN_NS,
 };
 use darkfi_money_contract::{
     client::{MoneyNote, OwnCoin},
@@ -61,10 +61,10 @@ impl TestHarness {
         let wallet = self.holders.get(proposer).unwrap();
 
         let (dao_propose_burn_pk, dao_propose_burn_zkbin) =
-            self.proving_keys.get(DAO_CONTRACT_ZKAS_DAO_PROPOSE_INPUT_NS).unwrap();
+            self.proving_keys.get(DAO_CONTRACT_ZKAS_PROPOSE_INPUT_NS).unwrap();
 
         let (dao_propose_main_pk, dao_propose_main_zkbin) =
-            self.proving_keys.get(DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS).unwrap();
+            self.proving_keys.get(DAO_CONTRACT_ZKAS_PROPOSE_MAIN_NS).unwrap();
 
         let propose_owncoin: OwnCoin = wallet
             .unspent_money_coins
@@ -201,10 +201,10 @@ impl TestHarness {
         let wallet = self.holders.get(proposer).unwrap();
 
         let (dao_propose_burn_pk, dao_propose_burn_zkbin) =
-            self.proving_keys.get(DAO_CONTRACT_ZKAS_DAO_PROPOSE_INPUT_NS).unwrap();
+            self.proving_keys.get(DAO_CONTRACT_ZKAS_PROPOSE_INPUT_NS).unwrap();
 
         let (dao_propose_main_pk, dao_propose_main_zkbin) =
-            self.proving_keys.get(DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS).unwrap();
+            self.proving_keys.get(DAO_CONTRACT_ZKAS_PROPOSE_MAIN_NS).unwrap();
 
         let propose_owncoin: OwnCoin = wallet
             .unspent_money_coins

src/contract/test-harness/src/dao_vote.rs

@@ -24,7 +24,7 @@ use darkfi_dao_contract::{
     blockwindow,
     client::{DaoVoteCall, DaoVoteInput},
     model::{Dao, DaoProposal, DaoVoteParams},
-    DaoFunction, DAO_CONTRACT_ZKAS_DAO_VOTE_INPUT_NS, DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS,
+    DaoFunction, DAO_CONTRACT_ZKAS_VOTE_INPUT_NS, DAO_CONTRACT_ZKAS_VOTE_MAIN_NS,
 };
 use darkfi_money_contract::{
     client::{MoneyNote, OwnCoin},
@@ -52,10 +52,10 @@ impl TestHarness {
         let wallet = self.holders.get(voter).unwrap();
 
         let (dao_vote_burn_pk, dao_vote_burn_zkbin) =
-            self.proving_keys.get(DAO_CONTRACT_ZKAS_DAO_VOTE_INPUT_NS).unwrap();
+            self.proving_keys.get(DAO_CONTRACT_ZKAS_VOTE_INPUT_NS).unwrap();
 
         let (dao_vote_main_pk, dao_vote_main_zkbin) =
-            self.proving_keys.get(DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS).unwrap();
+            self.proving_keys.get(DAO_CONTRACT_ZKAS_VOTE_MAIN_NS).unwrap();
 
         let (_, snapshot_money_merkle_tree) =
             wallet.dao_prop_leafs.get(&proposal.to_bulla()).unwrap();

src/contract/test-harness/src/vks.rs

@@ -29,11 +29,10 @@ use darkfi::{
     Result,
 };
 use darkfi_dao_contract::{
-    DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_ENC_COIN_NS,
-    DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS, DAO_CONTRACT_ZKAS_DAO_EARLY_EXEC_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,
+    DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_ENC_COIN_NS, DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_NS,
+    DAO_CONTRACT_ZKAS_EARLY_EXEC_NS, DAO_CONTRACT_ZKAS_EXEC_NS, DAO_CONTRACT_ZKAS_MINT_NS,
+    DAO_CONTRACT_ZKAS_PROPOSE_INPUT_NS, DAO_CONTRACT_ZKAS_PROPOSE_MAIN_NS,
+    DAO_CONTRACT_ZKAS_VOTE_INPUT_NS, DAO_CONTRACT_ZKAS_VOTE_MAIN_NS,
 };
 use darkfi_money_contract::{
     MONEY_CONTRACT_ZKAS_AUTH_TOKEN_MINT_NS_V1, MONEY_CONTRACT_ZKAS_BURN_NS_V1,
@@ -202,15 +201,15 @@ pub fn inject(sled_db: &sled::Db, vks: &Vks) -> Result<()> {
             }
 
             // DAO contract circuits
-            DAO_CONTRACT_ZKAS_DAO_MINT_NS |
-            DAO_CONTRACT_ZKAS_DAO_VOTE_INPUT_NS |
-            DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS |
-            DAO_CONTRACT_ZKAS_DAO_PROPOSE_INPUT_NS |
-            DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS |
-            DAO_CONTRACT_ZKAS_DAO_EXEC_NS |
-            DAO_CONTRACT_ZKAS_DAO_EARLY_EXEC_NS |
-            DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_NS |
-            DAO_CONTRACT_ZKAS_DAO_AUTH_MONEY_TRANSFER_ENC_COIN_NS => {
+            DAO_CONTRACT_ZKAS_MINT_NS |
+            DAO_CONTRACT_ZKAS_VOTE_INPUT_NS |
+            DAO_CONTRACT_ZKAS_VOTE_MAIN_NS |
+            DAO_CONTRACT_ZKAS_PROPOSE_INPUT_NS |
+            DAO_CONTRACT_ZKAS_PROPOSE_MAIN_NS |
+            DAO_CONTRACT_ZKAS_EXEC_NS |
+            DAO_CONTRACT_ZKAS_EARLY_EXEC_NS |
+            DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_NS |
+            DAO_CONTRACT_ZKAS_AUTH_MONEY_TRANSFER_ENC_COIN_NS => {
                 let key = serialize(&namespace.as_str());
                 let value = serialize(&(bincode.clone(), vk.clone()));
                 dao_tree.insert(key, value)?;