contract/test-harness: Revert to using a single reference for ProvingKey map.

bin/darkfid2/src/main.rs

@@ -113,9 +113,12 @@ async fn realmain(args: Args, ex: Arc<smol::Executor<'_>>) -> Result<()> {
     }
 
     // NOTE: everything is dummy for now
+    // FIXME: The VKS should only ever have to be generated on initial run.
+    //        Do not use the precompiles for actual production code.
     // Initialize or open sled database
     let sled_db = sled::Config::new().temporary(true).open()?;
-    vks::inject(&sled_db)?;
+    let (_, vks) = vks::read_or_gen_vks_and_pks()?;
+    vks::inject(&sled_db, &vks)?;
 
     // Initialize validator configuration
     let genesis_block = BlockInfo::default();

bin/darkfid2/src/tests/harness.rs

@@ -77,13 +77,16 @@ impl Harness {
         // Generate validators using pregenerated vks
         let sync_p2p = P2p::new(Settings::default()).await;
         let sled_db = sled::Config::new().temporary(true).open()?;
-        vks::inject(&sled_db)?;
+
+        let (_, vks) = vks::read_or_gen_vks_and_pks()?;
+        vks::inject(&sled_db, &vks)?;
+
         let validator = Validator::new(&sled_db, val_config.clone()).await?;
         let alice = Darkfid::new(sync_p2p, None, validator).await;
 
         let sync_p2p = P2p::new(Settings::default()).await;
         let sled_db = sled::Config::new().temporary(true).open()?;
-        vks::inject(&sled_db)?;
+        vks::inject(&sled_db, &vks)?;
         let validator = Validator::new(&sled_db, val_config.clone()).await?;
         let bob = Darkfid::new(sync_p2p, None, validator).await;
 

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

@@ -43,10 +43,11 @@ impl TestHarness {
         let wallet = self.holders.get(holder).unwrap();
 
         let (mint_pk, mint_zkbin) =
-            wallet.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
 
         let tx_action_benchmark =
             self.tx_action_benchmarks.get_mut(&TxAction::ConsensusGenesisStake).unwrap();
+
         let timer = Instant::now();
 
         // Building Consensus::GenesisStake params
@@ -97,8 +98,10 @@ impl TestHarness {
         slot: u64,
     ) -> Result<()> {
         let wallet = self.holders.get_mut(holder).unwrap();
+
         let tx_action_benchmark =
             self.tx_action_benchmarks.get_mut(&TxAction::ConsensusGenesisStake).unwrap();
+
         let timer = Instant::now();
 
         wallet.validator.read().await.add_transactions(&[tx.clone()], slot, true).await?;

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

@@ -46,10 +46,11 @@ impl TestHarness {
         let wallet = self.holders.get(holder).unwrap();
 
         let (proposal_pk, proposal_zkbin) =
-            wallet.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_PROPOSAL_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_PROPOSAL_NS_V1.to_string()).unwrap();
 
         let tx_action_benchmark =
             self.tx_action_benchmarks.get_mut(&TxAction::ConsensusProposal).unwrap();
+
         let timer = Instant::now();
 
         // Proposals always extend genesis block
@@ -104,8 +105,10 @@ impl TestHarness {
         slot: u64,
     ) -> Result<()> {
         let wallet = self.holders.get_mut(holder).unwrap();
+
         let tx_action_benchmark =
             self.tx_action_benchmarks.get_mut(&TxAction::ConsensusProposal).unwrap();
+
         let timer = Instant::now();
 
         wallet.validator.read().await.add_transactions(&[tx.clone()], slot, true).await?;

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

@@ -47,12 +47,14 @@ impl TestHarness {
         let wallet = self.holders.get(holder).unwrap();
 
         let (mint_pk, mint_zkbin) =
-            wallet.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
+
         let (burn_pk, burn_zkbin) =
-            wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap();
 
         let tx_action_benchmark =
             self.tx_action_benchmarks.get_mut(&TxAction::ConsensusStake).unwrap();
+
         let epoch = wallet.validator.read().await.consensus.time_keeper.slot_epoch(slot);
         let timer = Instant::now();
 
@@ -130,8 +132,10 @@ impl TestHarness {
         slot: u64,
     ) -> Result<()> {
         let wallet = self.holders.get_mut(holder).unwrap();
+
         let tx_action_benchmark =
             self.tx_action_benchmarks.get_mut(&TxAction::ConsensusStake).unwrap();
+
         let timer = Instant::now();
 
         wallet.validator.read().await.add_transactions(&[tx.clone()], slot, true).await?;

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

@@ -46,12 +46,13 @@ impl TestHarness {
         let wallet = self.holders.get(holder).unwrap();
 
         let (burn_pk, burn_zkbin) =
-            wallet.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap();
         let (mint_pk, mint_zkbin) =
-            wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
 
         let tx_action_benchmark =
             self.tx_action_benchmarks.get_mut(&TxAction::ConsensusUnstake).unwrap();
+
         let timer = Instant::now();
 
         // Building Consensus::Unstake params

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

@@ -46,9 +46,10 @@ impl TestHarness {
         let wallet = self.holders.get(holder).unwrap();
 
         let (burn_pk, burn_zkbin) =
-            wallet.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap();
+
         let (mint_pk, mint_zkbin) =
-            wallet.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&CONSENSUS_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
 
         let tx_action_benchmark =
             self.tx_action_benchmarks.get_mut(&TxAction::ConsensusUnstakeRequest).unwrap();
@@ -115,8 +116,10 @@ impl TestHarness {
         slot: u64,
     ) -> Result<()> {
         let wallet = self.holders.get_mut(holder).unwrap();
+
         let tx_action_benchmark =
             self.tx_action_benchmarks.get_mut(&TxAction::ConsensusUnstakeRequest).unwrap();
+
         let timer = Instant::now();
 
         wallet.validator.read().await.add_transactions(&[tx.clone()], slot, true).await?;

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

@@ -54,11 +54,11 @@ impl TestHarness {
         let dao_wallet = self.holders.get(&Holder::Dao).unwrap();
 
         let (mint_pk, mint_zkbin) =
-            dao_wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
         let (burn_pk, burn_zkbin) =
-            dao_wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap();
         let (dao_exec_pk, dao_exec_zkbin) =
-            dao_wallet.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_EXEC_NS.to_string()).unwrap();
+            self.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_EXEC_NS.to_string()).unwrap();
 
         let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::DaoExec).unwrap();
         let timer = Instant::now();

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

@@ -37,11 +37,8 @@ impl TestHarness {
         dao_info: &DaoInfo,
         dao_kp: &Keypair,
     ) -> Result<(Transaction, DaoMintParams)> {
-        // We assume DAO Holder exists at least
-        let wallet = self.holders.get(&Holder::Dao).unwrap();
-
         let (dao_mint_pk, dao_mint_zkbin) =
-            wallet.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_MINT_NS.to_string()).unwrap();
+            self.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_MINT_NS.to_string()).unwrap();
 
         let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::DaoMint).unwrap();
         let timer = Instant::now();

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

@@ -48,9 +48,9 @@ impl TestHarness {
         let wallet = self.holders.get(proposer).unwrap();
 
         let (dao_propose_burn_pk, dao_propose_burn_zkbin) =
-            wallet.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_PROPOSE_BURN_NS.to_string()).unwrap();
+            self.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_PROPOSE_BURN_NS.to_string()).unwrap();
         let (dao_propose_main_pk, dao_propose_main_zkbin) =
-            wallet.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS.to_string()).unwrap();
+            self.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_PROPOSE_MAIN_NS.to_string()).unwrap();
 
         let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::DaoPropose).unwrap();
         let timer = Instant::now();

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

@@ -48,9 +48,11 @@ impl TestHarness {
         let wallet = self.holders.get(voter).unwrap();
 
         let (dao_vote_burn_pk, dao_vote_burn_zkbin) =
-            wallet.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_VOTE_BURN_NS.to_string()).unwrap();
+            self.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_VOTE_BURN_NS.to_string()).unwrap();
+
         let (dao_vote_main_pk, dao_vote_main_zkbin) =
-            wallet.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS.to_string()).unwrap();
+            self.proving_keys.get(&DAO_CONTRACT_ZKAS_DAO_VOTE_MAIN_NS.to_string()).unwrap();
+
         let tx_action_benchmark = self.tx_action_benchmarks.get_mut(&TxAction::DaoVote).unwrap();
         let timer = Instant::now();
 

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

@@ -51,6 +51,7 @@ use rand::rngs::OsRng;
 mod benchmarks;
 use benchmarks::TxActionBenchmarks;
 pub mod vks;
+use vks::{read_or_gen_vks_and_pks, Vks};
 
 mod consensus_genesis_stake;
 mod consensus_proposal;
@@ -122,7 +123,6 @@ pub struct Wallet {
     pub keypair: Keypair,
     pub token_mint_authority: Keypair,
     pub validator: ValidatorPtr,
-    pub proving_keys: HashMap<String, (ProvingKey, ZkBinary)>,
     pub money_merkle_tree: MerkleTree,
     pub consensus_staked_merkle_tree: MerkleTree,
     pub consensus_unstaked_merkle_tree: MerkleTree,
@@ -141,21 +141,13 @@ impl Wallet {
         keypair: Keypair,
         genesis_block: &BlockInfo,
         faucet_pubkeys: &[PublicKey],
+        vks: &Vks,
     ) -> Result<Self> {
         let wallet = WalletDb::new(None, None)?;
         let sled_db = sled::Config::new().temporary(true).open()?;
 
         // Use pregenerated vks and get pregenerated pks
-        let pks = vks::inject(&sled_db)?;
-
-        let mut proving_keys = HashMap::new();
-        for (bincode, namespace, pk) in pks {
-            let mut reader = Cursor::new(pk);
-            let zkbin = ZkBinary::decode(&bincode)?;
-            let circuit = ZkCircuit::new(empty_witnesses(&zkbin), &zkbin);
-            let _pk = ProvingKey::read(&mut reader, circuit)?;
-            proving_keys.insert(namespace, (_pk, zkbin));
-        }
+        vks::inject(&sled_db, vks)?;
 
         // Generate validator
         // NOTE: we are not using consensus constants here so we
@@ -186,7 +178,6 @@ impl Wallet {
 
         Ok(Self {
             keypair,
-            proving_keys,
             token_mint_authority,
             validator,
             money_merkle_tree,
@@ -205,6 +196,7 @@ impl Wallet {
 
 pub struct TestHarness {
     pub holders: HashMap<Holder, Wallet>,
+    pub proving_keys: HashMap<String, (ProvingKey, ZkBinary)>,
     pub tx_action_benchmarks: HashMap<TxAction, TxActionBenchmarks>,
     pub genesis_block: blake3::Hash,
 }
@@ -218,29 +210,41 @@ impl TestHarness {
         // Deterministic PRNG
         let mut rng = Pcg32::new(42);
 
+        // Build or read precompiled zk pks and vks
+        let (pks, vks) = read_or_gen_vks_and_pks()?;
+
+        let mut proving_keys = HashMap::new();
+        for (bincode, namespace, pk) in pks {
+            let mut reader = Cursor::new(pk);
+            let zkbin = ZkBinary::decode(&bincode)?;
+            let circuit = ZkCircuit::new(empty_witnesses(&zkbin), &zkbin);
+            let _pk = ProvingKey::read(&mut reader, circuit)?;
+            proving_keys.insert(namespace, (_pk, zkbin));
+        }
+
         let faucet_kp = Keypair::random(&mut rng);
         let faucet_pubkeys = vec![faucet_kp.public];
-        let faucet = Wallet::new(faucet_kp, &genesis_block, &faucet_pubkeys).await?;
+        let faucet = Wallet::new(faucet_kp, &genesis_block, &faucet_pubkeys, &vks).await?;
         holders.insert(Holder::Faucet, faucet);
 
         let alice_kp = Keypair::random(&mut rng);
-        let alice = Wallet::new(alice_kp, &genesis_block, &faucet_pubkeys).await?;
+        let alice = Wallet::new(alice_kp, &genesis_block, &faucet_pubkeys, &vks).await?;
         holders.insert(Holder::Alice, alice);
 
         let bob_kp = Keypair::random(&mut rng);
-        let bob = Wallet::new(bob_kp, &genesis_block, &faucet_pubkeys).await?;
+        let bob = Wallet::new(bob_kp, &genesis_block, &faucet_pubkeys, &vks).await?;
         holders.insert(Holder::Bob, bob);
 
         let charlie_kp = Keypair::random(&mut rng);
-        let charlie = Wallet::new(charlie_kp, &genesis_block, &faucet_pubkeys).await?;
+        let charlie = Wallet::new(charlie_kp, &genesis_block, &faucet_pubkeys, &vks).await?;
         holders.insert(Holder::Charlie, charlie);
 
         let rachel_kp = Keypair::random(&mut rng);
-        let rachel = Wallet::new(rachel_kp, &genesis_block, &faucet_pubkeys).await?;
+        let rachel = Wallet::new(rachel_kp, &genesis_block, &faucet_pubkeys, &vks).await?;
         holders.insert(Holder::Rachel, rachel);
 
         let dao_kp = Keypair::random(&mut rng);
-        let dao = Wallet::new(dao_kp, &genesis_block, &faucet_pubkeys).await?;
+        let dao = Wallet::new(dao_kp, &genesis_block, &faucet_pubkeys, &vks).await?;
         holders.insert(Holder::Dao, dao);
 
         // Build benchmarks map
@@ -262,7 +266,12 @@ impl TestHarness {
         tx_action_benchmarks.insert(TxAction::DaoVote, TxActionBenchmarks::default());
         tx_action_benchmarks.insert(TxAction::DaoExec, TxActionBenchmarks::default());
 
-        Ok(Self { holders, tx_action_benchmarks, genesis_block: genesis_block.blockhash() })
+        Ok(Self {
+            holders,
+            proving_keys,
+            tx_action_benchmarks,
+            genesis_block: genesis_block.blockhash(),
+        })
     }
 
     pub async fn execute_erroneous_txs(

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

@@ -47,12 +47,16 @@ impl TestHarness {
     ) -> Result<(Transaction, MoneyTransferParamsV1)> {
         let recipient = self.holders.get(holder).unwrap().keypair.public;
         let faucet = self.holders.get(&Holder::Faucet).unwrap();
+
         let (mint_pk, mint_zkbin) =
-            faucet.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
+
         let (burn_pk, burn_zkbin) =
-            faucet.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap();
+
         let tx_action_benchmark =
             self.tx_action_benchmarks.get_mut(&TxAction::MoneyAirdrop).unwrap();
+
         let timer = Instant::now();
 
         let builder = TransferCallBuilder {

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

@@ -40,10 +40,13 @@ impl TestHarness {
         amount: u64,
     ) -> Result<(Transaction, MoneyTokenMintParamsV1)> {
         let wallet = self.holders.get(holder).unwrap();
+
         let (mint_pk, mint_zkbin) =
-            wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
+
         let tx_action_benchmark =
             self.tx_action_benchmarks.get_mut(&TxAction::MoneyGenesisMint).unwrap();
+
         let timer = Instant::now();
 
         // We're just going to be using a zero spend-hook and user-data

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

@@ -44,12 +44,16 @@ impl TestHarness {
     ) -> Result<(Transaction, MoneyTransferParamsV1)> {
         let wallet0 = self.holders.get(holder0).unwrap();
         let wallet1 = self.holders.get(holder1).unwrap();
+
         let (mint_pk, mint_zkbin) =
-            wallet0.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
+
         let (burn_pk, burn_zkbin) =
-            wallet0.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap();
+
         let tx_action_benchmark =
             self.tx_action_benchmarks.get_mut(&TxAction::MoneyOtcSwap).unwrap();
+
         let timer = Instant::now();
 
         // We're just going to be using a zero spend-hook and user-data

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

@@ -49,7 +49,7 @@ impl TestHarness {
         let rcpt = self.holders.get(recipient).unwrap().keypair.public;
 
         let (mint_pk, mint_zkbin) =
-            wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_TOKEN_MINT_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&MONEY_CONTRACT_ZKAS_TOKEN_MINT_NS_V1.to_string()).unwrap();
 
         let tx_action_benchmark =
             self.tx_action_benchmarks.get_mut(&TxAction::MoneyTokenMint).unwrap();
@@ -113,10 +113,13 @@ impl TestHarness {
     ) -> Result<(Transaction, MoneyTokenFreezeParamsV1)> {
         let wallet = self.holders.get(holder).unwrap();
         let mint_authority = wallet.token_mint_authority;
+
         let (frz_pk, frz_zkbin) =
-            wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_TOKEN_FRZ_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&MONEY_CONTRACT_ZKAS_TOKEN_FRZ_NS_V1.to_string()).unwrap();
+
         let tx_action_benchmark =
             self.tx_action_benchmarks.get_mut(&TxAction::MoneyTokenFreeze).unwrap();
+
         let timer = Instant::now();
 
         let builder = TokenFreezeCallBuilder {

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

@@ -45,12 +45,16 @@ impl TestHarness {
     ) -> Result<(Transaction, MoneyTransferParamsV1, Vec<OwnCoin>)> {
         let wallet = self.holders.get(holder).unwrap();
         let rcpt = self.holders.get(recipient).unwrap().keypair.public;
+
         let (mint_pk, mint_zkbin) =
-            wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&MONEY_CONTRACT_ZKAS_MINT_NS_V1.to_string()).unwrap();
+
         let (burn_pk, burn_zkbin) =
-            wallet.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap();
+            self.proving_keys.get(&MONEY_CONTRACT_ZKAS_BURN_NS_V1.to_string()).unwrap();
+
         let tx_action_benchmark =
             self.tx_action_benchmarks.get_mut(&TxAction::MoneyTransfer).unwrap();
+
         let timer = Instant::now();
 
         // We're just going to be using a zero spend-hook and user-data

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

@@ -65,7 +65,7 @@ fn pks_path(typ: &str) -> Result<PathBuf> {
 pub type Vks = Vec<(Vec<u8>, String, Vec<u8>)>;
 pub type Pks = Vec<(Vec<u8>, String, Vec<u8>)>;
 
-fn read_or_gen_vks_and_pks() -> Result<(Pks, Vks)> {
+pub fn read_or_gen_vks_and_pks() -> Result<(Pks, Vks)> {
     let vks_path = pks_path("vks.bin")?;
     let pks_path = pks_path("pks.bin")?;
 
@@ -171,11 +171,8 @@ fn read_or_gen_vks_and_pks() -> Result<(Pks, Vks)> {
     Ok((pks, vks))
 }
 
-pub fn inject(sled_db: &sled::Db) -> Result<Pks> {
-    // Use pregenerated vks
-    let (pks, vks) = read_or_gen_vks_and_pks()?;
-
-    // Inject them into the db
+pub fn inject(sled_db: &sled::Db, vks: &Vks) -> Result<()> {
+    // Inject vks into the db
     let money_zkas_tree_ptr = MONEY_CONTRACT_ID.hash_state_id(SMART_CONTRACT_ZKAS_DB_NAME);
     let money_zkas_tree = sled_db.open_tree(money_zkas_tree_ptr)?;
 
@@ -233,5 +230,5 @@ pub fn inject(sled_db: &sled::Db) -> Result<Pks> {
         }
     }
 
-    Ok(pks)
+    Ok(())
 }