bin: WIP changes for Halo2.

src/bin/cashierd.rs

@@ -1,28 +1,26 @@
-use async_std::sync::{Arc, Mutex};
 use std::{path::PathBuf, str::FromStr};
 
 use async_executor::Executor;
+use async_std::sync::{Arc, Mutex};
 use async_trait::async_trait;
 use clap::clap_app;
 use easy_parallel::Parallel;
-use ff::Field;
 use log::debug;
-use rand::rngs::OsRng;
+use pasta_curves::pallas;
 use serde_json::{json, Value};
 
 use drk::{
     blockchain::{rocks::columns, Rocks, RocksColumn},
     cli::{CashierdConfig, Config},
     client::{Client, State},
-    crypto::{
-        load_params, merkle::CommitmentTree, save_params, setup_mint_prover, setup_spend_prover,
-    },
+    crypto::{mint_proof::MintProofKeys, schnorr, spend_proof::SpendProofKeys},
     rpc::{
         jsonrpc::{error as jsonerr, response as jsonresp, ErrorCode::*, JsonRequest, JsonResult},
         rpcserver::{listen_and_serve, RequestHandler, RpcServerConfig},
     },
     serial::{deserialize, serialize},
     service::{bridge, bridge::Bridge},
+    types::DrkTokenId,
     util::{expand_path, generate_id, join_config_path, parse::truncate, NetworkName},
     wallet::{cashierdb::TokenKey, CashierDb, WalletDb},
     Error, Result,
@@ -97,10 +95,11 @@ impl Cashierd {
 
         Ok(Self { bridge, cashier_wallet, networks, public_key: String::from(""), config })
     }
+
     async fn listen_for_receiving_coins(
         bridge: Arc<Bridge>,
         cashier_wallet: Arc<CashierDb>,
-        recv_coin: async_channel::Receiver<(jubjub::SubgroupPoint, u64)>,
+        recv_coin: async_channel::Receiver<(pallas::Point, u64)>,
         executor: Arc<Executor<'_>>,
     ) -> Result<()> {
         // received drk coin
@@ -109,7 +108,8 @@ impl Cashierd {
         debug!(target: "CASHIER DAEMON", "Receive coin with amount: {}", amount);
 
         // get public key, and token_id of the token
-        let token = cashier_wallet.get_withdraw_token_public_key_by_dkey_public(&drk_pub_key)?;
+        let token =
+            cashier_wallet.get_withdraw_token_public_key_by_dkey_public(&drk_pub_key).await?;
 
         // send a request to bridge to send equivalent amount of
         // received drk coin to token publickey
@@ -143,10 +143,12 @@ impl Cashierd {
 
             match res.payload {
                 bridge::BridgeResponsePayload::Send => {
-                    cashier_wallet.confirm_withdraw_key_record(
-                        &withdraw_token.token_public_key,
-                        &withdraw_token.network,
-                    )?;
+                    cashier_wallet
+                        .confirm_withdraw_key_record(
+                            &withdraw_token.token_public_key,
+                            &withdraw_token.network,
+                        )
+                        .await?;
                 }
                 _ => {
                     return Err(Error::BridgeError("Receive unknown value from Subscription".into()))
@@ -202,12 +204,13 @@ impl Cashierd {
                 mint_address = "";
             }
             let drk_pub_key = bs58::decode(&drk_pub_key).into_vec()?;
-            let drk_pub_key: jubjub::SubgroupPoint = deserialize(&drk_pub_key)?;
+            let drk_pub_key: pallas::Point = deserialize(&drk_pub_key)?;
 
             // check if the drk public key already exist
             let check = self
                 .cashier_wallet
-                .get_deposit_token_keys_by_dkey_public(&drk_pub_key, &network)?;
+                .get_deposit_token_keys_by_dkey_public(&drk_pub_key, &network)
+                .await?;
 
             // start new subscription from the bridge and then cashierd will
             // send a request to the bridge to generate keypair for the desired token
@@ -256,14 +259,16 @@ impl Cashierd {
             match bridge_res.payload {
                 bridge::BridgeResponsePayload::Watch(token_key) => {
                     // add pairings to db
-                    self.cashier_wallet.put_deposit_keys(
-                        &drk_pub_key,
-                        &token_key.private_key,
-                        &serialize(&token_key.public_key),
-                        &network,
-                        &token_id,
-                        mint_address.into(),
-                    )?;
+                    self.cashier_wallet
+                        .put_deposit_keys(
+                            &drk_pub_key,
+                            &token_key.private_key,
+                            &serialize(&token_key.public_key),
+                            &network,
+                            &token_id,
+                            mint_address.into(),
+                        )
+                        .await?;
 
                     Ok(token_key.public_key)
                 }
@@ -316,7 +321,7 @@ impl Cashierd {
         }
 
         let result: Result<String> = async {
-            let token_id = generate_id(mint_address, &network)?;
+            let token_id: DrkTokenId = generate_id(mint_address, &network)?;
 
             let mint_address_opt = Self::check_token_id(&network, mint_address)?;
 
@@ -327,25 +332,28 @@ impl Cashierd {
 
             let address = serialize(&address.to_string());
 
-            let cashier_public: jubjub::SubgroupPoint;
+            let cashier_public: pallas::Point;
 
-            if let Some(addr) =
-                self.cashier_wallet.get_withdraw_keys_by_token_public_key(&address, &network)?
+            if let Some(addr) = self
+                .cashier_wallet
+                .get_withdraw_keys_by_token_public_key(&address, &network)
+                .await?
             {
                 cashier_public = addr.public;
             } else {
-                let cashier_secret = jubjub::Fr::random(&mut OsRng);
-                cashier_public =
-                    zcash_primitives::constants::SPENDING_KEY_GENERATOR * cashier_secret;
-
-                self.cashier_wallet.put_withdraw_keys(
-                    &address,
-                    &cashier_public,
-                    &cashier_secret,
-                    &network,
-                    &token_id,
-                    mint_address.into(),
-                )?;
+                let cashier_secret = schnorr::SecretKey::random();
+                cashier_public = cashier_secret.public_key();
+
+                self.cashier_wallet
+                    .put_withdraw_keys(
+                        &address,
+                        &cashier_public,
+                        &cashier_secret,
+                        &network,
+                        &token_id,
+                        mint_address.into(),
+                    )
+                    .await?;
             }
 
             let cashier_public_str = bs58::encode(serialize(&cashier_public)).into_string();
@@ -452,18 +460,21 @@ impl Cashierd {
 
                     let main_keypair: Keypair;
 
-                    let main_keypairs = self.cashier_wallet.get_main_keys(&NetworkName::Solana)?;
+                    let main_keypairs =
+                        self.cashier_wallet.get_main_keys(&NetworkName::Solana).await?;
 
                     if network.keypair.is_empty() {
                         if main_keypairs.is_empty() {
                             main_keypair = Keypair::new();
-                            self.cashier_wallet.put_main_keys(
-                                &TokenKey {
-                                    private_key: serialize(&main_keypair),
-                                    public_key: serialize(&main_keypair.pubkey()),
-                                },
-                                &NetworkName::Solana,
-                            )?;
+                            self.cashier_wallet
+                                .put_main_keys(
+                                    &TokenKey {
+                                        private_key: serialize(&main_keypair),
+                                        public_key: serialize(&main_keypair.pubkey()),
+                                    },
+                                    &NetworkName::Solana,
+                                )
+                                .await?;
                         } else {
                             main_keypair =
                                 deserialize(&main_keypairs[main_keypairs.len() - 1].private_key)?;
@@ -495,7 +506,7 @@ impl Cashierd {
                     let main_keypair: Keypair;
 
                     let main_keypairs =
-                        self.cashier_wallet.get_main_keys(&NetworkName::Ethereum)?;
+                        self.cashier_wallet.get_main_keys(&NetworkName::Ethereum).await?;
 
                     let passphrase = self.config.geth_passphrase.clone();
 
@@ -513,13 +524,15 @@ impl Cashierd {
                             .unwrap()
                             .to_string();
 
-                        self.cashier_wallet.put_main_keys(
-                            &TokenKey {
-                                private_key: serialize(&main_private_key),
-                                public_key: serialize(&main_public_key),
-                            },
-                            &NetworkName::Ethereum,
-                        )?;
+                        self.cashier_wallet
+                            .put_main_keys(
+                                &TokenKey {
+                                    private_key: serialize(&main_private_key),
+                                    public_key: serialize(&main_public_key),
+                                },
+                                &NetworkName::Ethereum,
+                            )
+                            .await?;
 
                         main_keypair =
                             Keypair { private_key: main_private_key, public_key: main_public_key };
@@ -546,18 +559,21 @@ impl Cashierd {
 
                     let main_keypair: Keypair;
 
-                    let main_keypairs = self.cashier_wallet.get_main_keys(&NetworkName::Bitcoin)?;
+                    let main_keypairs =
+                        self.cashier_wallet.get_main_keys(&NetworkName::Bitcoin).await?;
 
                     if network.keypair.is_empty() {
                         if main_keypairs.is_empty() {
                             main_keypair = Keypair::new();
-                            self.cashier_wallet.put_main_keys(
-                                &TokenKey {
-                                    private_key: serialize(&main_keypair),
-                                    public_key: serialize(&main_keypair.pubkey()),
-                                },
-                                &NetworkName::Bitcoin,
-                            )?;
+                            self.cashier_wallet
+                                .put_main_keys(
+                                    &TokenKey {
+                                        private_key: serialize(&main_keypair),
+                                        public_key: serialize(&main_keypair.pubkey()),
+                                    },
+                                    &NetworkName::Bitcoin,
+                                )
+                                .await?;
                         } else {
                             main_keypair =
                                 deserialize(&main_keypairs[main_keypairs.len() - 1].private_key)?;
@@ -581,7 +597,7 @@ impl Cashierd {
 
         client.start().await?;
 
-        let (notify, recv_coin) = async_channel::unbounded::<(jubjub::SubgroupPoint, u64)>();
+        let (notify, recv_coin) = async_channel::unbounded::<(pallas::Point, u64)>();
 
         client
             .connect_to_subscriber_from_cashier(
@@ -653,33 +669,15 @@ async fn start(
 
     let rocks = Rocks::new(expand_path(&config.database_path.clone())?.as_path())?;
 
-    let params_paths = (
-        expand_path(&config.mint_params_path.clone())?,
-        expand_path(&config.spend_params_path.clone())?,
-    );
-
-    let mint_params_path = params_paths.0.to_str().unwrap_or("mint.params");
-    let spend_params_path = params_paths.1.to_str().unwrap_or("spend.params");
-    // Auto create trusted ceremony parameters if they don't exist
-    if !params_paths.0.exists() {
-        let params = setup_mint_prover();
-        save_params(mint_params_path, &params)?;
-    }
-    if !params_paths.1.exists() {
-        let params = setup_spend_prover();
-        save_params(spend_params_path, &params)?;
-    }
-
-    // Load trusted setup parameters
-    let (mint_params, mint_pvk) = load_params(mint_params_path)?;
-    let (spend_params, spend_pvk) = load_params(spend_params_path)?;
+    let mint_proof_keys = MintProofKeys::initialize();
+    let spend_proof_keys = SpendProofKeys::initialize();
 
     let client = Client::new(
         rocks.clone(),
         (config.gateway_protocol_url.parse()?, config.gateway_publisher_url.parse()?),
         client_wallet.clone(),
-        mint_params,
-        spend_params,
+        mint_proof_keys,
+        spend_proof_keys,
     )
     .await?;
 
@@ -693,11 +691,11 @@ async fn start(
     let cashier_public_keys = vec![cashier_public];
 
     let state = Arc::new(Mutex::new(State {
-        tree: CommitmentTree::empty(),
+        tree: BridgeTree::<MerkleNode, 32>::new(100),
         merkle_roots,
         nullifiers,
-        mint_pvk,
-        spend_pvk,
+        mint_vk: mint_proof_keys.vk,
+        spend_vk: spend_proof_keys.vk,
         public_keys: cashier_public_keys,
     }));
 
@@ -759,7 +757,7 @@ async fn main() -> Result<()> {
             config.cashier_wallet_password.clone(),
         )?;
 
-        wallet.remove_withdraw_and_deposit_keys()?;
+        wallet.remove_withdraw_and_deposit_keys().await?;
 
         if let Some(path) = expand_path(&config.database_path)?.to_str() {
             debug!(target: "CASHIER DAEMON", "Remove database: {}", path);

src/bin/tx2.rs

@@ -35,14 +35,14 @@ struct MemoryState {
     spend_vk: VerifyingKey,
 
     // Public key of the cashier
-    cashier_public: schnorr::PublicKey,
+    cashier_signature_public: schnorr::PublicKey,
     // List of all our secret keys
     secrets: Vec<pallas::Base>,
 }
 
 impl ProgramState for MemoryState {
     fn is_valid_cashier_public_key(&self, public: &schnorr::PublicKey) -> bool {
-        public == &self.cashier_public
+        public == &self.cashier_signature_public
     }
 
     fn is_valid_merkle(&self, merkle_root: &MerkleNode) -> bool {
@@ -98,8 +98,8 @@ impl MemoryState {
 }
 
 fn main() -> Result<()> {
-    let cashier_secret = schnorr::SecretKey::random();
-    let cashier_public = cashier_secret.public_key();
+    let cashier_signature_secret = schnorr::SecretKey::random();
+    let cashier_signature_public = cashier_secret.public_key();
 
     let keypair = Keypair::random(&mut OsRng);
 
@@ -114,8 +114,8 @@ fn main() -> Result<()> {
         own_coins: vec![],
         mint_vk,
         spend_vk,
-        cashier_public,
-        secrets: vec![keypair.secret],
+        cashier_signature_public,
+        secrets: vec![keypair.secret.inner()],
     };
 
     let token_id = pallas::Base::from(110);
@@ -124,13 +124,13 @@ fn main() -> Result<()> {
         clear_inputs: vec![tx::TransactionBuilderClearInputInfo {
             value: 110,
             token_id,
-            signature_secret: cashier_secret,
+            signature_secret: cashier_signature_secret,
         }],
         inputs: vec![],
         outputs: vec![tx::TransactionBuilderOutputInfo {
             value: 110,
             token_id,
-            public: keypair.public,
+            public: keypair.public.inner(),
         }],
     };
 
@@ -138,7 +138,7 @@ fn main() -> Result<()> {
 
     tx.verify(&state.mint_vk, &state.spend_vk).expect("tx verify");
 
-    let _note = tx.outputs[0].enc_note.decrypt(&keypair.secret)?;
+    let _note = tx.outputs[0].enc_note.decrypt(&keypair.secret.inner())?;
 
     let update = state_transition(&state, tx)?;
     state.apply(update);
@@ -153,13 +153,13 @@ fn main() -> Result<()> {
         inputs: vec![tx::TransactionBuilderInputInfo {
             leaf_position,
             merkle_path,
-            secret: keypair.secret,
+            secret: keypair.secret.inner(),
             note: note.clone(),
         }],
         outputs: vec![tx::TransactionBuilderOutputInfo {
             value: 110,
             token_id,
-            public: keypair.public,
+            public: keypair.public.inner(),
         }],
     };
 

src/bin/vm2.rs

@@ -1,39 +1,11 @@
-use halo2::{
-    circuit::{Layouter, SimpleFloorPlanner},
-    dev::MockProver,
-    plonk::{
-        Advice, Circuit, Column, ConstraintSystem, Error, Instance as InstanceColumn, Selector,
-    },
-    poly::Rotation,
-};
+use halo2::dev::MockProver;
 use halo2_gadgets::{
-    ecc::{
-        chip::{EccChip, EccConfig},
-        FixedPoint, FixedPoints,
-    },
-    poseidon::{
-        Hash as PoseidonHash, Pow5T3Chip as PoseidonChip, Pow5T3Config as PoseidonConfig,
-        StateWord, Word,
-    },
     primitives,
-    primitives::{
-        poseidon::{ConstantLength, P128Pow5T3},
-        sinsemilla::S_PERSONALIZATION,
-    },
-    sinsemilla::{
-        chip::{SinsemillaChip, SinsemillaConfig},
-        merkle::{
-            chip::{MerkleChip, MerkleConfig},
-            MerklePath,
-        },
-    },
-    utilities::{
-        lookup_range_check::LookupRangeCheckConfig, CellValue, UtilitiesInstructions, Var,
-    },
+    primitives::poseidon::{ConstantLength, P128Pow5T3},
 };
 use pasta_curves::{
     arithmetic::{CurveAffine, Field},
-    group::{ff::PrimeFieldBits, Curve, Group},
+    group::{Curve, Group},
     pallas,
 };
 use rand::rngs::OsRng;
@@ -41,12 +13,9 @@ use std::{collections::HashMap, fs::File, time::Instant};
 
 use drk::{
     crypto::{
-        constants::{
-            sinsemilla::{OrchardCommitDomains, OrchardHashDomains, MERKLE_CRH_PERSONALIZATION},
-            OrchardFixedBases,
-        },
+        constants::OrchardFixedBases,
         proof::{Proof, ProvingKey, VerifyingKey},
-        util::{pedersen_commitment_scalar, pedersen_commitment_u64},
+        util::pedersen_commitment_u64,
     },
     serial::Decodable,
     vm,
@@ -94,7 +63,7 @@ fn main() -> std::result::Result<(), failure::Error> {
         coin += primitives::poseidon::Hash::init(P128Pow5T3, ConstantLength::<2>).hash(*msg);
     }
 
-    let coin2 = primitives::poseidon::Hash::init(P128Pow5T3, ConstantLength::<2>)
+    let _coin2 = primitives::poseidon::Hash::init(P128Pow5T3, ConstantLength::<2>)
         .hash([*coords.x(), *coords.y()]);
 
     let value_commit = pedersen_commitment_u64(value, value_blind);
@@ -103,7 +72,7 @@ fn main() -> std::result::Result<(), failure::Error> {
     let asset_commit = pedersen_commitment_u64(asset, asset_blind);
     let asset_coords = asset_commit.to_affine().coordinates().unwrap();
 
-    let mut public_inputs =
+    let public_inputs =
         vec![coin, *value_coords.x(), *value_coords.y(), *asset_coords.x(), *asset_coords.y()];
 
     let mut const_fixed_points = HashMap::new();

src/bin/vm2_burn.rs

@@ -1,41 +1,17 @@
 use std::iter;
 
-use halo2::{
-    circuit::{Layouter, SimpleFloorPlanner},
-    dev::MockProver,
-    plonk::{
-        Advice, Circuit, Column, ConstraintSystem, Error, Instance as InstanceColumn, Selector,
-    },
-    poly::Rotation,
-};
+use halo2::dev::MockProver;
 use halo2_gadgets::{
-    ecc::{
-        chip::{EccChip, EccConfig},
-        FixedPoint, FixedPoints,
-    },
-    poseidon::{
-        Hash as PoseidonHash, Pow5T3Chip as PoseidonChip, Pow5T3Config as PoseidonConfig,
-        StateWord, Word,
-    },
+    ecc::FixedPoints,
     primitives,
     primitives::{
         poseidon::{ConstantLength, P128Pow5T3},
         sinsemilla::S_PERSONALIZATION,
     },
-    sinsemilla::{
-        chip::{SinsemillaChip, SinsemillaConfig},
-        merkle::{
-            chip::{MerkleChip, MerkleConfig},
-            MerklePath,
-        },
-    },
-    utilities::{
-        lookup_range_check::LookupRangeCheckConfig, CellValue, UtilitiesInstructions, Var,
-    },
 };
 use pasta_curves::{
     arithmetic::{CurveAffine, Field},
-    group::{ff::PrimeFieldBits, Curve, Group},
+    group::{ff::PrimeFieldBits, Curve},
     pallas,
 };
 use rand::rngs::OsRng;
@@ -44,16 +20,14 @@ use std::{collections::HashMap, fs::File, time::Instant};
 use drk::{
     crypto::{
         constants::{
-            sinsemilla::{
-                i2lebsp, OrchardCommitDomains, OrchardHashDomains, MERKLE_CRH_PERSONALIZATION,
-            },
+            sinsemilla::{i2lebsp, MERKLE_CRH_PERSONALIZATION},
             OrchardFixedBases,
         },
         proof::{Proof, ProvingKey, VerifyingKey},
-        util::{pedersen_commitment_scalar, pedersen_commitment_u64},
+        util::pedersen_commitment_u64,
     },
     serial::Decodable,
-    vm2,
+    vm,
 };
 
 fn root(path: [pallas::Base; 32], leaf_pos: u32, leaf: pallas::Base) -> pallas::Base {
@@ -84,7 +58,7 @@ fn main() -> std::result::Result<(), failure::Error> {
 
     let start = Instant::now();
     let file = File::open("proof/burn.zk.bin")?;
-    let zkbin = vm2::ZkBinary::decode(file)?;
+    let zkbin = vm::ZkBinary::decode(file)?;
     for contract_name in zkbin.contracts.keys() {
         println!("Loaded '{}' contract.", contract_name);
     }
@@ -167,7 +141,7 @@ fn main() -> std::result::Result<(), failure::Error> {
     const_fixed_points.insert("VALUE_COMMIT_RANDOM".to_string(), OrchardFixedBases::ValueCommitR);
     const_fixed_points.insert("SPEND_AUTH_G".to_string(), OrchardFixedBases::SpendAuthG);
 
-    let mut circuit = vm2::ZkCircuit::new(const_fixed_points, &zkbin.constants, contract);
+    let mut circuit = vm::ZkCircuit::new(const_fixed_points, &zkbin.constants, contract);
     let empty_circuit = circuit.clone();
 
     circuit.witness_base("secret", hashed_secret_key)?;