dao2: Update calls for latest darkfi-sdk changes.

example/dao2/.gitignore

@@ -1,4 +1,4 @@
-dao
+/dao
 *.wasm
 *.zk.bin
 target/

example/dao2/Cargo.lock

@@ -970,6 +970,7 @@ dependencies = [
 name = "darkfi-sdk"
 version = "0.3.0"
 dependencies = [
+ "blake2b_simd",
  "blake3",
  "bs58",
  "darkfi-serial",
@@ -977,6 +978,8 @@ dependencies = [
  "incrementalmerkletree",
  "lazy_static",
  "pasta_curves",
+ "rand_core",
+ "sha2",
  "subtle",
  "thiserror",
 ]

example/dao2/contract/dao/src/lib.rs

@@ -1,16 +1,16 @@
 use darkfi_sdk::{
-    crypto::{constants::MERKLE_DEPTH, ContractId, MerkleNode, MerkleTree, Nullifier},
-    db::{db_get, db_init, db_lookup, db_set},
+    crypto::{ContractId, MerkleNode, MerkleTree},
+    db::{db_init, db_lookup, db_set},
     define_contract,
     error::ContractResult,
     merkle::merkle_add,
     msg,
     pasta::pallas,
     tx::ContractCall,
-    util::{get_object_bytes, get_object_size, put_object_bytes, set_return_data},
+    util::set_return_data,
 };
 use darkfi_serial::{
-    deserialize, serialize, Encodable, ReadExt, SerialDecodable, SerialEncodable, WriteExt,
+    deserialize, serialize, Encodable, SerialDecodable, SerialEncodable, WriteExt,
 };
 
 #[derive(Clone, SerialEncodable, SerialDecodable)]
@@ -103,8 +103,8 @@ fn process_instruction(cid: ContractId, ix: &[u8]) -> ContractResult {
             let update = DaoMintUpdate { dao_bulla: params.dao_bulla };
 
             let mut update_data = Vec::new();
-            update_data.write_u8(DaoFunction::Mint as u8);
-            update.encode(&mut update_data);
+            update_data.write_u8(DaoFunction::Mint as u8)?;
+            update.encode(&mut update_data)?;
             set_return_data(&update_data)?;
             msg!("update is set!");
         }

example/dao2/contract/money/src/lib.rs

@@ -1,16 +1,12 @@
 use darkfi_sdk::{
     crypto::ContractId,
-    db::{db_get, db_init, db_lookup, db_set},
+    db::{db_init, db_lookup, db_set},
     define_contract,
     error::ContractResult,
-    msg,
     pasta::pallas,
-    tx::ContractCall,
-    util::{get_object_bytes, get_object_size, put_object_bytes, set_return_data},
-};
-use darkfi_serial::{
-    deserialize, serialize, Encodable, ReadExt, SerialDecodable, SerialEncodable, WriteExt,
+    util::set_return_data,
 };
+use darkfi_serial::{serialize, Encodable, SerialDecodable, SerialEncodable};
 
 #[repr(u8)]
 pub enum MoneyFunction {

example/dao2/src/contract/dao/exec/validate.rs

@@ -18,6 +18,8 @@
 
 use std::any::{Any, TypeId};
 
+use darkfi_sdk::crypto::PublicKey;
+use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable};
 use pasta_curves::{
     arithmetic::CurveAffine,
     group::{Curve, Group},
@@ -25,10 +27,9 @@ use pasta_curves::{
 };
 
 use darkfi::{
-    crypto::{coin::Coin, keypair::PublicKey, types::DrkCircuitField},
+    crypto::{coin::Coin, types::DrkCircuitField},
     Error as DarkFiError,
 };
-use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable};
 
 use crate::{
     contract::{dao, dao::CONTRACT_ID, money},

example/dao2/src/contract/dao/exec/wallet.rs

@@ -16,17 +16,14 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+use darkfi_sdk::crypto::{pedersen::pedersen_commitment_u64, SecretKey};
 use halo2_proofs::circuit::Value;
 use log::debug;
 use pasta_curves::{arithmetic::CurveAffine, group::Curve, pallas};
 use rand::rngs::OsRng;
 
 use darkfi::{
-    crypto::{
-        keypair::SecretKey,
-        util::{pedersen_commitment_u64, poseidon_hash},
-        Proof,
-    },
+    crypto::{util::poseidon_hash, Proof},
     zk::vm::{Witness, ZkCircuit},
 };
 
@@ -59,7 +56,7 @@ impl Builder {
         debug!(target: "dao_contract::exec::wallet::Builder", "build()");
         let mut proofs = vec![];
 
-        let proposal_dest_coords = self.proposal.dest.0.to_affine().coordinates().unwrap();
+        let (proposal_dest_x, proposal_dest_y) = self.proposal.dest.xy();
 
         let proposal_amount = pallas::Base::from(self.proposal.amount);
 
@@ -68,7 +65,7 @@ impl Builder {
         let dao_approval_ratio_quot = pallas::Base::from(self.dao.approval_ratio_quot);
         let dao_approval_ratio_base = pallas::Base::from(self.dao.approval_ratio_base);
 
-        let dao_pubkey_coords = self.dao.public_key.0.to_affine().coordinates().unwrap();
+        let (dao_pub_x, dao_pub_y) = self.dao.public_key.xy();
 
         let user_spend_hook = pallas::Base::from(0);
         let user_data = pallas::Base::from(0);
@@ -81,14 +78,14 @@ impl Builder {
             dao_approval_ratio_quot,
             dao_approval_ratio_base,
             self.dao.gov_token_id,
-            *dao_pubkey_coords.x(),
-            *dao_pubkey_coords.y(),
+            dao_pub_x,
+            dao_pub_y,
             self.dao.bulla_blind,
         ]);
 
         let proposal_bulla = poseidon_hash::<8>([
-            *proposal_dest_coords.x(),
-            *proposal_dest_coords.y(),
+            proposal_dest_x,
+            proposal_dest_y,
             proposal_amount,
             self.proposal.serial,
             self.proposal.token_id,
@@ -99,8 +96,8 @@ impl Builder {
         ]);
 
         let coin_0 = poseidon_hash::<8>([
-            *proposal_dest_coords.x(),
-            *proposal_dest_coords.y(),
+            proposal_dest_x,
+            proposal_dest_y,
             proposal_amount,
             self.proposal.token_id,
             self.proposal.serial,
@@ -110,8 +107,8 @@ impl Builder {
         ]);
 
         let coin_1 = poseidon_hash::<8>([
-            *dao_pubkey_coords.x(),
-            *dao_pubkey_coords.y(),
+            dao_pub_x,
+            dao_pub_y,
             change,
             self.proposal.token_id,
             self.dao_serial,
@@ -141,8 +138,8 @@ impl Builder {
         let prover_witnesses = vec![
             //
             // proposal params
-            Witness::Base(Value::known(*proposal_dest_coords.x())),
-            Witness::Base(Value::known(*proposal_dest_coords.y())),
+            Witness::Base(Value::known(proposal_dest_x)),
+            Witness::Base(Value::known(proposal_dest_y)),
             Witness::Base(Value::known(proposal_amount)),
             Witness::Base(Value::known(self.proposal.serial)),
             Witness::Base(Value::known(self.proposal.token_id)),
@@ -153,8 +150,8 @@ impl Builder {
             Witness::Base(Value::known(dao_approval_ratio_quot)),
             Witness::Base(Value::known(dao_approval_ratio_base)),
             Witness::Base(Value::known(self.dao.gov_token_id)),
-            Witness::Base(Value::known(*dao_pubkey_coords.x())),
-            Witness::Base(Value::known(*dao_pubkey_coords.y())),
+            Witness::Base(Value::known(dao_pub_x)),
+            Witness::Base(Value::known(dao_pub_y)),
             Witness::Base(Value::known(self.dao.bulla_blind)),
             // votes
             Witness::Base(Value::known(pallas::Base::from(self.yes_votes_value))),

example/dao2/src/contract/dao/mint/validate.rs

@@ -18,7 +18,8 @@
 
 use std::any::{Any, TypeId};
 
-use darkfi::crypto::{keypair::PublicKey, types::DrkCircuitField};
+use darkfi::crypto::types::DrkCircuitField;
+use darkfi_sdk::crypto::PublicKey;
 use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable};
 
 use crate::{

example/dao2/src/contract/dao/mint/wallet.rs

@@ -16,16 +16,13 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
+use darkfi_sdk::crypto::{PublicKey, SecretKey};
 use halo2_proofs::circuit::Value;
 use pasta_curves::{arithmetic::CurveAffine, group::Curve, pallas};
 use rand::rngs::OsRng;
 
 use darkfi::{
-    crypto::{
-        keypair::{PublicKey, SecretKey},
-        util::poseidon_hash,
-        Proof,
-    },
+    crypto::{util::poseidon_hash, Proof},
     zk::vm::{Witness, ZkCircuit},
 };
 
@@ -67,7 +64,7 @@ impl Builder {
         let dao_approval_ratio_quot = pallas::Base::from(self.dao_approval_ratio_quot);
         let dao_approval_ratio_base = pallas::Base::from(self.dao_approval_ratio_base);
 
-        let dao_pubkey_coords = self.dao_pubkey.0.to_affine().coordinates().unwrap();
+        let (dao_pub_x, dao_pub_y) = self.dao_pubkey.xy();
 
         let dao_bulla = poseidon_hash::<8>([
             dao_proposer_limit,
@@ -75,8 +72,8 @@ impl Builder {
             dao_approval_ratio_quot,
             dao_approval_ratio_base,
             self.gov_token_id,
-            *dao_pubkey_coords.x(),
-            *dao_pubkey_coords.y(),
+            dao_pub_x,
+            dao_pub_y,
             self.dao_bulla_blind,
         ]);
         let dao_bulla = DaoBulla(dao_bulla);
@@ -95,8 +92,8 @@ impl Builder {
             Witness::Base(Value::known(dao_approval_ratio_quot)),
             Witness::Base(Value::known(dao_approval_ratio_base)),
             Witness::Base(Value::known(self.gov_token_id)),
-            Witness::Base(Value::known(*dao_pubkey_coords.x())),
-            Witness::Base(Value::known(*dao_pubkey_coords.y())),
+            Witness::Base(Value::known(dao_pub_x)),
+            Witness::Base(Value::known(dao_pub_y)),
             Witness::Base(Value::known(self.dao_bulla_blind)),
         ];
         let public_inputs = vec![dao_bulla.0];

example/dao2/src/contract/dao/propose/validate.rs

@@ -18,7 +18,7 @@
 
 use std::any::{Any, TypeId};
 
-use darkfi_sdk::crypto::MerkleNode;
+use darkfi_sdk::crypto::{MerkleNode, PublicKey};
 use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable};
 use log::error;
 use pasta_curves::{
@@ -27,10 +27,7 @@ use pasta_curves::{
     pallas,
 };
 
-use darkfi::{
-    crypto::{keypair::PublicKey, types::DrkCircuitField},
-    Error as DarkFiError,
-};
+use darkfi::{crypto::types::DrkCircuitField, Error as DarkFiError};
 
 use crate::{
     contract::{dao, dao::State as DaoState, money, money::state::State as MoneyState},
@@ -76,7 +73,7 @@ impl CallDataBase for CallData {
             total_funds_commit += input.value_commit;
             let value_coords = input.value_commit.to_affine().coordinates().unwrap();
 
-            let sigpub_coords = input.signature_public.0.to_affine().coordinates().unwrap();
+            let (sig_x, sig_y) = input.signature_public.xy();
 
             zk_publics.push((
                 "dao-propose-burn".to_string(),
@@ -85,8 +82,8 @@ impl CallDataBase for CallData {
                     *value_coords.y(),
                     self.header.token_commit,
                     input.merkle_root.inner(),
-                    *sigpub_coords.x(),
-                    *sigpub_coords.y(),
+                    sig_x,
+                    sig_y,
                 ],
             ));
         }

example/dao2/src/contract/dao/propose/wallet.rs

@@ -16,7 +16,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use darkfi_sdk::crypto::MerkleNode;
+use darkfi_sdk::crypto::{pedersen::pedersen_commitment_u64, MerkleNode, PublicKey, SecretKey};
 use darkfi_serial::{SerialDecodable, SerialEncodable};
 use halo2_proofs::circuit::Value;
 use incrementalmerkletree::Hashable;
@@ -28,11 +28,7 @@ use pasta_curves::{
 use rand::rngs::OsRng;
 
 use darkfi::{
-    crypto::{
-        keypair::{PublicKey, SecretKey},
-        util::{pedersen_commitment_u64, poseidon_hash},
-        Proof,
-    },
+    crypto::{util::poseidon_hash, Proof},
     zk::vm::{Witness, ZkCircuit},
 };
 
@@ -110,7 +106,7 @@ impl Builder {
             let leaf_pos: u64 = input.leaf_position.into();
 
             let prover_witnesses = vec![
-                Witness::Base(Value::known(input.secret.0)),
+                Witness::Base(Value::known(input.secret.inner())),
                 Witness::Base(Value::known(note.serial)),
                 Witness::Base(Value::known(pallas::Base::from(0))),
                 Witness::Base(Value::known(pallas::Base::from(0))),
@@ -121,15 +117,15 @@ impl Builder {
                 Witness::Base(Value::known(gov_token_blind)),
                 Witness::Uint32(Value::known(leaf_pos.try_into().unwrap())),
                 Witness::MerklePath(Value::known(input.merkle_path.clone().try_into().unwrap())),
-                Witness::Base(Value::known(input.signature_secret.0)),
+                Witness::Base(Value::known(input.signature_secret.inner())),
             ];
 
             let public_key = PublicKey::from_secret(input.secret);
-            let coords = public_key.0.to_affine().coordinates().unwrap();
+            let (pub_x, pub_y) = public_key.xy();
 
             let coin = poseidon_hash::<8>([
-                *coords.x(),
-                *coords.y(),
+                pub_x,
+                pub_y,
                 pallas::Base::from(note.value),
                 note.token_id,
                 note.serial,
@@ -158,15 +154,15 @@ impl Builder {
             let value_commit = pedersen_commitment_u64(note.value, funds_blind);
             let value_coords = value_commit.to_affine().coordinates().unwrap();
 
-            let sigpub_coords = signature_public.0.to_affine().coordinates().unwrap();
+            let (sig_x, sig_y) = signature_public.xy();
 
             let public_inputs = vec![
                 *value_coords.x(),
                 *value_coords.y(),
                 token_commit,
                 merkle_root.inner(),
-                *sigpub_coords.x(),
-                *sigpub_coords.y(),
+                sig_x,
+                sig_y,
             ];
             let circuit = ZkCircuit::new(prover_witnesses, zk_bin);
 
@@ -185,9 +181,7 @@ impl Builder {
 
         let token_commit = poseidon_hash::<2>([self.dao.gov_token_id, gov_token_blind]);
 
-        let proposal_dest_coords = self.proposal.dest.0.to_affine().coordinates().unwrap();
-        let proposal_dest_x = *proposal_dest_coords.x();
-        let proposal_dest_y = *proposal_dest_coords.y();
+        let (proposal_dest_x, proposal_dest_y) = self.proposal.dest.xy();
 
         let proposal_amount = pallas::Base::from(self.proposal.amount);
 
@@ -196,7 +190,7 @@ impl Builder {
         let dao_approval_ratio_quot = pallas::Base::from(self.dao.approval_ratio_quot);
         let dao_approval_ratio_base = pallas::Base::from(self.dao.approval_ratio_base);
 
-        let dao_pubkey_coords = self.dao.public_key.0.to_affine().coordinates().unwrap();
+        let (dao_pub_x, dao_pub_y) = self.dao.public_key.xy();
 
         let dao_bulla = poseidon_hash::<8>([
             dao_proposer_limit,
@@ -204,8 +198,8 @@ impl Builder {
             dao_approval_ratio_quot,
             dao_approval_ratio_base,
             self.dao.gov_token_id,
-            *dao_pubkey_coords.x(),
-            *dao_pubkey_coords.y(),
+            dao_pub_x,
+            dao_pub_y,
             self.dao.bulla_blind,
         ]);
 
@@ -249,8 +243,8 @@ impl Builder {
             Witness::Base(Value::known(dao_approval_ratio_quot)),
             Witness::Base(Value::known(dao_approval_ratio_base)),
             Witness::Base(Value::known(self.dao.gov_token_id)),
-            Witness::Base(Value::known(*dao_pubkey_coords.x())),
-            Witness::Base(Value::known(*dao_pubkey_coords.y())),
+            Witness::Base(Value::known(dao_pub_x)),
+            Witness::Base(Value::known(dao_pub_y)),
             Witness::Base(Value::known(self.dao.bulla_blind)),
             Witness::Uint32(Value::known(dao_leaf_position.try_into().unwrap())),
             Witness::MerklePath(Value::known(self.dao_merkle_path.try_into().unwrap())),

example/dao2/src/contract/dao/vote/validate.rs

@@ -18,7 +18,7 @@
 
 use std::any::{Any, TypeId};
 
-use darkfi_sdk::crypto::{MerkleNode, Nullifier};
+use darkfi_sdk::crypto::{MerkleNode, Nullifier, PublicKey};
 use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable};
 use log::error;
 use pasta_curves::{
@@ -27,10 +27,7 @@ use pasta_curves::{
     pallas,
 };
 
-use darkfi::{
-    crypto::{keypair::PublicKey, types::DrkCircuitField},
-    Error as DarkFiError,
-};
+use darkfi::{crypto::types::DrkCircuitField, Error as DarkFiError};
 
 use crate::{
     contract::{dao, dao::State as DaoState, money, money::state::State as MoneyState},
@@ -79,7 +76,7 @@ impl CallDataBase for CallData {
             all_votes_commit += input.vote_commit;
             let value_coords = input.vote_commit.to_affine().coordinates().unwrap();
 
-            let sigpub_coords = input.signature_public.0.to_affine().coordinates().unwrap();
+            let (sig_x, sig_y) = input.signature_public.xy();
 
             zk_publics.push((
                 "dao-vote-burn".to_string(),
@@ -89,8 +86,8 @@ impl CallDataBase for CallData {
                     *value_coords.y(),
                     self.header.token_commit,
                     input.merkle_root.inner(),
-                    *sigpub_coords.x(),
-                    *sigpub_coords.y(),
+                    sig_x,
+                    sig_y,
                 ],
             ));
         }

example/dao2/src/contract/dao/vote/wallet.rs

@@ -16,7 +16,9 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use darkfi_sdk::crypto::{MerkleNode, Nullifier};
+use darkfi_sdk::crypto::{
+    pedersen::pedersen_commitment_u64, Keypair, MerkleNode, Nullifier, PublicKey, SecretKey,
+};
 use darkfi_serial::{SerialDecodable, SerialEncodable};
 use halo2_proofs::circuit::Value;
 use incrementalmerkletree::Hashable;
@@ -29,11 +31,7 @@ use pasta_curves::{
 use rand::rngs::OsRng;
 
 use darkfi::{
-    crypto::{
-        keypair::{Keypair, PublicKey, SecretKey},
-        util::{pedersen_commitment_u64, poseidon_hash},
-        Proof,
-    },
+    crypto::{util::poseidon_hash, Proof},
     zk::vm::{Witness, ZkCircuit},
 };
 
@@ -115,7 +113,7 @@ impl Builder {
             let leaf_pos: u64 = input.leaf_position.into();
 
             let prover_witnesses = vec![
-                Witness::Base(Value::known(input.secret.0)),
+                Witness::Base(Value::known(input.secret.inner())),
                 Witness::Base(Value::known(note.serial)),
                 Witness::Base(Value::known(pallas::Base::from(0))),
                 Witness::Base(Value::known(pallas::Base::from(0))),
@@ -126,15 +124,15 @@ impl Builder {
                 Witness::Base(Value::known(gov_token_blind)),
                 Witness::Uint32(Value::known(leaf_pos.try_into().unwrap())),
                 Witness::MerklePath(Value::known(input.merkle_path.clone().try_into().unwrap())),
-                Witness::Base(Value::known(input.signature_secret.0)),
+                Witness::Base(Value::known(input.signature_secret.inner())),
             ];
 
             let public_key = PublicKey::from_secret(input.secret);
-            let coords = public_key.0.to_affine().coordinates().unwrap();
+            let (pub_x, pub_y) = public_key.xy();
 
             let coin = poseidon_hash::<8>([
-                *coords.x(),
-                *coords.y(),
+                pub_x,
+                pub_y,
                 pallas::Base::from(note.value),
                 note.token_id,
                 note.serial,
@@ -160,12 +158,12 @@ impl Builder {
             let token_commit = poseidon_hash::<2>([note.token_id, gov_token_blind]);
             assert_eq!(self.dao.gov_token_id, note.token_id);
 
-            let nullifier = poseidon_hash::<2>([input.secret.0, note.serial]);
+            let nullifier = poseidon_hash::<2>([input.secret.inner(), note.serial]);
 
             let vote_commit = pedersen_commitment_u64(note.value, vote_value_blind);
             let vote_commit_coords = vote_commit.to_affine().coordinates().unwrap();
 
-            let sigpub_coords = signature_public.0.to_affine().coordinates().unwrap();
+            let (sig_x, sig_y) = signature_public.xy();
 
             let public_inputs = vec![
                 nullifier,
@@ -173,8 +171,8 @@ impl Builder {
                 *vote_commit_coords.y(),
                 token_commit,
                 merkle_root.inner(),
-                *sigpub_coords.x(),
-                *sigpub_coords.y(),
+                sig_x,
+                sig_y,
             ];
 
             let circuit = ZkCircuit::new(prover_witnesses, zk_bin);
@@ -195,7 +193,7 @@ impl Builder {
 
         let token_commit = poseidon_hash::<2>([self.dao.gov_token_id, gov_token_blind]);
 
-        let proposal_dest_coords = self.proposal.dest.0.to_affine().coordinates().unwrap();
+        let (proposal_dest_x, proposal_dest_y) = self.proposal.dest.xy();
 
         let proposal_amount = pallas::Base::from(self.proposal.amount);
 
@@ -204,7 +202,7 @@ impl Builder {
         let dao_approval_ratio_quot = pallas::Base::from(self.dao.approval_ratio_quot);
         let dao_approval_ratio_base = pallas::Base::from(self.dao.approval_ratio_base);
 
-        let dao_pubkey_coords = self.dao.public_key.0.to_affine().coordinates().unwrap();
+        let (dao_pub_x, dao_pub_y) = self.dao.public_key.xy();
 
         let dao_bulla = poseidon_hash::<8>([
             dao_proposer_limit,
@@ -212,14 +210,14 @@ impl Builder {
             dao_approval_ratio_quot,
             dao_approval_ratio_base,
             self.dao.gov_token_id,
-            *dao_pubkey_coords.x(),
-            *dao_pubkey_coords.y(),
+            dao_pub_x,
+            dao_pub_y,
             self.dao.bulla_blind,
         ]);
 
         let proposal_bulla = poseidon_hash::<8>([
-            *proposal_dest_coords.x(),
-            *proposal_dest_coords.y(),
+            proposal_dest_x,
+            proposal_dest_y,
             proposal_amount,
             self.proposal.serial,
             self.proposal.token_id,
@@ -249,8 +247,8 @@ impl Builder {
 
         let prover_witnesses = vec![
             // proposal params
-            Witness::Base(Value::known(*proposal_dest_coords.x())),
-            Witness::Base(Value::known(*proposal_dest_coords.y())),
+            Witness::Base(Value::known(proposal_dest_x)),
+            Witness::Base(Value::known(proposal_dest_y)),
             Witness::Base(Value::known(proposal_amount)),
             Witness::Base(Value::known(self.proposal.serial)),
             Witness::Base(Value::known(self.proposal.token_id)),
@@ -261,8 +259,8 @@ impl Builder {
             Witness::Base(Value::known(dao_approval_ratio_quot)),
             Witness::Base(Value::known(dao_approval_ratio_base)),
             Witness::Base(Value::known(self.dao.gov_token_id)),
-            Witness::Base(Value::known(*dao_pubkey_coords.x())),
-            Witness::Base(Value::known(*dao_pubkey_coords.y())),
+            Witness::Base(Value::known(dao_pub_x)),
+            Witness::Base(Value::known(dao_pub_y)),
             Witness::Base(Value::known(self.dao.bulla_blind)),
             // Vote
             Witness::Base(Value::known(pallas::Base::from(vote_option))),

example/dao2/src/contract/example/foo/validate.rs

@@ -18,13 +18,10 @@
 
 use std::any::{Any, TypeId};
 
-use pasta_curves::pallas;
-
-use darkfi::{
-    crypto::{keypair::PublicKey, types::DrkCircuitField},
-    Error as DarkFiError,
-};
+use darkfi::{crypto::types::DrkCircuitField, Error as DarkFiError};
+use darkfi_sdk::crypto::PublicKey;
 use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable};
+use pasta_curves::pallas;
 
 use crate::{
     contract::example::{state::State, CONTRACT_ID},

example/dao2/src/contract/example/foo/wallet.rs

@@ -16,17 +16,14 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use log::debug;
-use rand::rngs::OsRng;
-
+use darkfi_sdk::crypto::{PublicKey, SecretKey};
 use halo2_proofs::circuit::Value;
+use log::debug;
 use pasta_curves::pallas;
+use rand::rngs::OsRng;
 
 use darkfi::{
-    crypto::{
-        keypair::{PublicKey, SecretKey},
-        Proof,
-    },
+    crypto::Proof,
     zk::vm::{Witness, ZkCircuit},
 };
 

example/dao2/src/contract/money/state.rs

@@ -16,8 +16,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use darkfi::crypto::keypair::PublicKey;
-use darkfi_sdk::crypto::{constants::MERKLE_DEPTH, MerkleNode, Nullifier};
+use darkfi_sdk::crypto::{constants::MERKLE_DEPTH, MerkleNode, Nullifier, PublicKey};
 use incrementalmerkletree::bridgetree::BridgeTree;
 
 type MerkleTree = BridgeTree<MerkleNode, { MERKLE_DEPTH }>;

example/dao2/src/contract/money/transfer/validate.rs

@@ -18,7 +18,10 @@
 
 use std::any::{Any, TypeId};
 
-use darkfi_sdk::crypto::{MerkleNode, Nullifier};
+use darkfi_sdk::crypto::{
+    pedersen::{pedersen_commitment_base, pedersen_commitment_u64},
+    MerkleNode, Nullifier, PublicKey,
+};
 use darkfi_serial::{Encodable, SerialDecodable, SerialEncodable};
 use incrementalmerkletree::Tree;
 use log::{debug, error};
@@ -27,9 +30,7 @@ use pasta_curves::{group::Group, pallas};
 use darkfi::{
     crypto::{
         coin::Coin,
-        keypair::PublicKey,
         types::{DrkCircuitField, DrkTokenId, DrkValueBlind, DrkValueCommit},
-        util::{pedersen_commitment_base, pedersen_commitment_u64},
         BurnRevealedValues, MintRevealedValues,
     },
     Error as DarkFiError,

example/dao2/src/contract/money/transfer/wallet.rs

@@ -16,7 +16,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-use darkfi_sdk::crypto::MerkleNode;
+use darkfi_sdk::crypto::{MerkleNode, PublicKey, SecretKey};
 use darkfi_serial::{SerialDecodable, SerialEncodable};
 use pasta_curves::group::ff::Field;
 use rand::rngs::OsRng;
@@ -24,7 +24,6 @@ use rand::rngs::OsRng;
 use darkfi::{
     crypto::{
         burn_proof::create_burn_proof,
-        keypair::{PublicKey, SecretKey},
         mint_proof::create_mint_proof,
         types::{
             DrkCoinBlind, DrkSerial, DrkSpendHook, DrkTokenId, DrkUserData, DrkUserDataBlind,

example/dao2/src/main.rs

@@ -3,10 +3,9 @@ use darkfi::{
     consensus::{TESTNET_GENESIS_HASH_BYTES, TESTNET_GENESIS_TIMESTAMP},
     crypto::{
         coin::Coin,
-        keypair::{Keypair, PublicKey, SecretKey},
         proof::{ProvingKey, VerifyingKey},
         types::{DrkSpendHook, DrkUserData, DrkValue},
-        util::{pedersen_commitment_u64, poseidon_hash},
+        util::poseidon_hash,
     },
     runtime::vm_runtime::Runtime,
     zk::circuit::{BurnContract, MintContract},
@@ -14,7 +13,10 @@ use darkfi::{
     Result,
 };
 use darkfi_sdk::{
-    crypto::{constants::MERKLE_DEPTH, ContractId, MerkleNode, MerkleTree},
+    crypto::{
+        constants::MERKLE_DEPTH, pedersen::pedersen_commitment_u64, ContractId, Keypair,
+        MerkleNode, MerkleTree, PublicKey, SecretKey,
+    },
     tx::ContractCall,
 };
 use darkfi_serial::{deserialize, serialize, Decodable, Encodable, WriteExt};
@@ -22,7 +24,7 @@ use incrementalmerkletree::{bridgetree::BridgeTree, Tree};
 use log::{debug, error};
 use pasta_curves::{
     arithmetic::CurveAffine,
-    group::{ff::Field, Curve, Group},
+    group::{ff::Field, Curve},
     pallas,
 };
 use rand::rngs::OsRng;
@@ -279,8 +281,7 @@ async fn main() -> BoxResult<()> {
                 let mut decoder = Cursor::new(&metadata);
                 let zk_public_values: Vec<(String, Vec<pallas::Base>)> =
                     Decodable::decode(&mut decoder)?;
-                let signature_public_keys: Vec<pallas::Point> =
-                    Decodable::decode(&mut decoder)?;
+                let signature_public_keys: Vec<pallas::Point> = Decodable::decode(&mut decoder)?;
 
                 zkpublic_table.push(zk_public_values);
                 sigpub_table.push(signature_public_keys);
@@ -296,8 +297,7 @@ async fn main() -> BoxResult<()> {
                 let mut decoder = Cursor::new(&metadata);
                 let zk_public_values: Vec<(String, Vec<pallas::Base>)> =
                     Decodable::decode(&mut decoder)?;
-                let signature_public_keys: Vec<pallas::Point> =
-                    Decodable::decode(&mut decoder)?;
+                let signature_public_keys: Vec<pallas::Point> = Decodable::decode(&mut decoder)?;
 
                 zkpublic_table.push(zk_public_values);
                 sigpub_table.push(signature_public_keys);

example/dao2/src/note.rs

@@ -17,13 +17,11 @@
  */
 
 use chacha20poly1305::{AeadInPlace, ChaCha20Poly1305, KeyInit};
+use darkfi_sdk::crypto::{PublicKey, SecretKey};
 use rand::rngs::OsRng;
 
 use darkfi::{
-    crypto::{
-        diffie_hellman::{kdf_sapling, sapling_ka_agree},
-        keypair::{PublicKey, SecretKey},
-    },
+    crypto::diffie_hellman::{kdf_sapling, sapling_ka_agree},
     Error, Result,
 };
 use darkfi_serial::{Decodable, Encodable, SerialDecodable, SerialEncodable};

example/dao2/src/schema.rs

@@ -21,27 +21,25 @@ use std::{
     time::Instant,
 };
 
+use darkfi_sdk::crypto::{
+    constants::MERKLE_DEPTH, pedersen::pedersen_commitment_u64, Keypair, MerkleNode, PublicKey,
+    SecretKey,
+};
 use incrementalmerkletree::{bridgetree::BridgeTree, Tree};
 use log::debug;
-use pasta_curves::{
-    arithmetic::CurveAffine,
-    group::{ff::Field, Curve, Group},
-    pallas,
-};
+use pasta_curves::{arithmetic::CurveAffine, group::Curve, pallas};
 use rand::rngs::OsRng;
 
 use darkfi::{
     crypto::{
         coin::Coin,
-        keypair::{Keypair, PublicKey, SecretKey},
         proof::{ProvingKey, VerifyingKey},
         types::{DrkSpendHook, DrkUserData, DrkValue},
-        util::{pedersen_commitment_u64, poseidon_hash},
+        util::poseidon_hash,
     },
     zk::circuit::{BurnContract, MintContract},
     zkas::decoder::ZkBinary,
 };
-use darkfi_sdk::crypto::{constants::MERKLE_DEPTH, MerkleNode};
 
 use crate::{
     contract::{dao, example, money},

example/dao2/src/tx.rs

@@ -1,12 +1,19 @@
+use darkfi::{crypto::Proof, Result, VerifyFailed::ProofVerifyFailed};
+use darkfi_sdk::{
+    crypto::{
+        schnorr::{SchnorrPublic, Signature},
+        PublicKey,
+    },
+    pasta::pallas,
+    tx::ContractCall,
+};
 use log::debug;
-use darkfi::{crypto::{schnorr::{SchnorrPublic, Signature}, Proof, keypair::PublicKey}, Result, VerifyFailed::ProofVerifyFailed};
-use darkfi_sdk::{tx::ContractCall, pasta::pallas};
 
 use crate::{
     contract::{dao, example, money},
     note::EncryptedNote2,
     schema::WalletCache,
-    util::{sign, StateRegistry, ZkContractTable, ZkContractInfo},
+    util::{sign, StateRegistry, ZkContractInfo, ZkContractTable},
 };
 
 macro_rules! zip {
@@ -27,7 +34,11 @@ impl Transaction {
     /// Verify ZK contracts for the entire tx
     /// In real code, we could parallelize this for loop
     /// TODO: fix use of unwrap with Result type stuff
-    pub fn zk_verify(&self, zk_bins: &ZkContractTable, zkpub_table: &Vec<Vec<(String, Vec<pallas::Base>)>>) -> Result<()> {
+    pub fn zk_verify(
+        &self,
+        zk_bins: &ZkContractTable,
+        zkpub_table: &Vec<Vec<(String, Vec<pallas::Base>)>>,
+    ) -> Result<()> {
         assert_eq!(
             self.calls.len(),
             self.proofs.len(),
@@ -51,9 +62,7 @@ impl Transaction {
                 pubvals.len()
             );
 
-            for (i, (proof, (key, public_vals))) in
-                proofs.iter().zip(pubvals.iter()).enumerate()
-            {
+            for (i, (proof, (key, public_vals))) in proofs.iter().zip(pubvals.iter()).enumerate() {
                 match zk_bins.lookup(key).unwrap() {
                     ZkContractInfo::Binary(info) => {
                         let verifying_key = &info.verifying_key;

example/dao2/src/util.rs

@@ -18,6 +18,11 @@
 
 use std::{any::Any, collections::HashMap, hash::Hasher};
 
+use darkfi_sdk::crypto::{
+    schnorr::{SchnorrPublic, SchnorrSecret, Signature},
+    PublicKey, SecretKey,
+};
+use darkfi_serial::Encodable;
 use lazy_static::lazy_static;
 use log::debug;
 use pasta_curves::{
@@ -28,16 +33,13 @@ use rand::rngs::OsRng;
 
 use darkfi::{
     crypto::{
-        keypair::{PublicKey, SecretKey},
         proof::{ProvingKey, VerifyingKey},
-        schnorr::{SchnorrPublic, SchnorrSecret, Signature},
         types::DrkCircuitField,
         Proof,
     },
     zk::{vm::ZkCircuit, vm_stack::empty_witnesses},
     zkas::decoder::ZkBinary,
 };
-use darkfi_serial::Encodable;
 
 use crate::error::{DaoError, DaoResult};
 
@@ -206,7 +208,7 @@ pub fn sign(signature_secrets: Vec<SecretKey>, func_call: &FuncCall) -> Vec<Sign
     let mut unsigned_tx_data = vec![];
     for signature_secret in signature_secrets {
         func_call.encode(&mut unsigned_tx_data).expect("failed to encode data");
-        let signature = signature_secret.sign(&unsigned_tx_data[..]);
+        let signature = signature_secret.sign(&mut OsRng, &unsigned_tx_data[..]);
         signatures.push(signature);
     }
     signatures