Next

.gitignore

@@ -1 +1,4 @@
 /target
+test.sqlite
+test.sqlite-wal
+test.sqlite-shm

migrations/20240314021456_init.sql

@@ -9,4 +9,20 @@ CREATE TABLE `unhardened_keys` (
     `index` INT UNSIGNED NOT NULL PRIMARY KEY,
     `public_key` BLOB NOT NULL,
     `p2_puzzle_hash` BLOB NOT NULL
+);
+
+CREATE TABLE `hardened_cats` (
+    `puzzle_hash` BLOB NOT NULL PRIMARY KEY,
+    `asset_id` BLOB NOT NULL,
+    `public_key` BLOB NOT NULL,
+    `puzzle_hash` BLOB NOT NULL
+);
+
+CREATE TABLE `coin_states` (
+    `coin_id` BLOB NOT NULL PRIMARY KEY,
+    `parent_coin_info` BLOB NOT NULL,
+    `puzzle_hash` BLOB NOT NULL,
+    `amount` BIGINT UNSIGNED NOT NULL,
+    `created_height` INT UNSIGNED,
+    `spent_height` INT UNSIGNED
 );

src/spends/cat.rs

@@ -10,7 +10,7 @@ use clvm_utils::{tree_hash, CurriedProgram};
 use clvmr::{allocator::NodePtr, serde::node_from_bytes, Allocator};
 use thiserror::Error;
 
-use crate::{CatCondition, DerivationStore};
+use crate::{CatCondition, PuzzleStore};
 
 mod issuance;
 mod raw_spend;
@@ -49,7 +49,7 @@ pub async fn construct_cat_spends(
     standard_puzzle_ptr: NodePtr,
     cat_puzzle_ptr: NodePtr,
     peer: &Peer,
-    derivation_store: &impl DerivationStore,
+    puzzle_store: &impl PuzzleStore,
     coins: Vec<Coin>,
     conditions: Vec<CatCondition<NodePtr>>,
     asset_id: [u8; 32],
@@ -65,12 +65,12 @@ pub async fn construct_cat_spends(
     for (i, coin) in coins.into_iter().enumerate() {
         // Coin info.
         let puzzle_hash = &coin.puzzle_hash;
-        let index = derivation_store
+        let index = puzzle_store
             .puzzle_hash_index(puzzle_hash.into())
             .await
             .expect("cannot spend coin with unknown puzzle hash");
 
-        let synthetic_key = derivation_store
+        let synthetic_key = puzzle_store
             .public_key(index)
             .await
             .expect("cannot spend coin with unknown public key");

src/spends/standard.rs

@@ -5,7 +5,7 @@ use clvm_traits::{clvm_quote, FromNodePtr, ToClvmError, ToNodePtr};
 use clvm_utils::CurriedProgram;
 use clvmr::{allocator::NodePtr, Allocator};
 
-use crate::{Condition, DerivationStore};
+use crate::{Condition, PuzzleStore};
 
 /// Creates a new coin spend for a given standard transaction coin.
 pub fn spend_standard_coin(
@@ -38,19 +38,19 @@ pub fn spend_standard_coin(
 pub async fn spend_standard_coins(
     a: &mut Allocator,
     standard_puzzle_ptr: NodePtr,
-    derivation_store: &impl DerivationStore,
+    puzzle_store: &impl PuzzleStore,
     coins: Vec<Coin>,
     conditions: &[Condition<NodePtr>],
 ) -> Vec<CoinSpend> {
     let mut coin_spends = Vec::new();
     for (i, coin) in coins.into_iter().enumerate() {
         let puzzle_hash = &coin.puzzle_hash;
-        let index = derivation_store
+        let index = puzzle_store
             .puzzle_hash_index(puzzle_hash.into())
             .await
             .expect("cannot spend coin with unknown puzzle hash");
 
-        let synthetic_key = derivation_store
+        let synthetic_key = puzzle_store
             .public_key(index)
             .await
             .expect("cannot spend coin with unknown public key");

src/sqlite.rs

@@ -1,5 +1,7 @@
+mod coin_store;
 mod hardened_key_store;
 mod unhardened_key_store;
 
+pub use coin_store::*;
 pub use hardened_key_store::*;
 pub use unhardened_key_store::*;

src/sqlite/coin_store.rs

@@ -0,0 +1,101 @@
+use chia_protocol::{Coin, CoinState};
+use sqlx::SqlitePool;
+
+pub struct CoinStore {
+    pool: SqlitePool,
+}
+
+impl CoinStore {
+    pub fn new(pool: SqlitePool) -> Self {
+        Self { pool }
+    }
+
+    pub async fn unspent_coins(&self) -> Vec<Coin> {
+        let rows = sqlx::query!(
+            "
+            SELECT `parent_coin_info`, `puzzle_hash`, `amount`
+            FROM `coin_states`
+            WHERE `spent_height` IS NULL
+            "
+        )
+        .fetch_all(&self.pool)
+        .await
+        .unwrap();
+
+        rows.into_iter()
+            .map(|row| {
+                let parent_coin_info = row.parent_coin_info;
+                let puzzle_hash = row.puzzle_hash;
+                let amount = row.amount as u64;
+
+                Coin {
+                    parent_coin_info: parent_coin_info.try_into().unwrap(),
+                    puzzle_hash: puzzle_hash.try_into().unwrap(),
+                    amount,
+                }
+            })
+            .collect()
+    }
+
+    pub async fn coin_state(&self, coin_id: [u8; 32]) -> CoinState {
+        let coin_id = coin_id.to_vec();
+
+        let row = sqlx::query!(
+            "
+            SELECT `parent_coin_info`, `puzzle_hash`, `amount`, `created_height`, `spent_height`
+            FROM `coin_states`
+            WHERE `coin_id` = ?
+            ",
+            coin_id
+        )
+        .fetch_one(&self.pool)
+        .await
+        .unwrap();
+
+        CoinState {
+            coin: Coin {
+                parent_coin_info: row.parent_coin_info.try_into().unwrap(),
+                puzzle_hash: row.puzzle_hash.try_into().unwrap(),
+                amount: row.amount as u64,
+            },
+            created_height: row.created_height.map(|height| height as u32),
+            spent_height: row.spent_height.map(|height| height as u32),
+        }
+    }
+
+    pub async fn apply_updates(&self, coin_states: Vec<CoinState>) {
+        let mut tx = self.pool.begin().await.unwrap();
+
+        for coin_state in coin_states {
+            let coin_id = coin_state.coin.coin_id().to_vec();
+            let parent_coin_info = coin_state.coin.parent_coin_info.to_bytes().to_vec();
+            let puzzle_hash = coin_state.coin.puzzle_hash.to_bytes().to_vec();
+            let amount = coin_state.coin.amount as i64;
+
+            sqlx::query!(
+                "
+                REPLACE INTO `coin_states` (
+                    `coin_id`,
+                    `parent_coin_info`,
+                    `puzzle_hash`,
+                    `amount`,
+                    `created_height`,
+                    `spent_height`
+                )
+                VALUES (?, ?, ?, ?, ?, ?)
+                ",
+                coin_id,
+                parent_coin_info,
+                puzzle_hash,
+                amount,
+                coin_state.created_height,
+                coin_state.spent_height
+            )
+            .execute(&mut *tx)
+            .await
+            .unwrap();
+        }
+
+        tx.commit().await.unwrap();
+    }
+}

src/sqlite/hardened_key_store.rs

@@ -2,7 +2,7 @@ use chia_bls::{PublicKey, SecretKey};
 use chia_wallet::{standard::standard_puzzle_hash, DeriveSynthetic};
 use sqlx::SqlitePool;
 
-use crate::{DerivationStore, KeyStore};
+use crate::{KeyStore, PuzzleStore};
 
 pub struct HardenedKeyStore {
     pool: SqlitePool,
@@ -97,7 +97,7 @@ impl KeyStore for HardenedKeyStore {
     }
 }
 
-impl DerivationStore for HardenedKeyStore {
+impl PuzzleStore for HardenedKeyStore {
     async fn puzzle_hash(&self, index: u32) -> Option<[u8; 32]> {
         sqlx::query!(
             "SELECT `p2_puzzle_hash` FROM `hardened_keys` WHERE `index` = ?",

src/sqlite/unhardened_key_store.rs

@@ -2,7 +2,7 @@ use chia_bls::{DerivableKey, PublicKey};
 use chia_wallet::{standard::standard_puzzle_hash, DeriveSynthetic};
 use sqlx::SqlitePool;
 
-use crate::{DerivationStore, KeyStore};
+use crate::{KeyStore, PuzzleStore};
 
 pub struct UnhardenedKeyStore {
     pool: SqlitePool,
@@ -109,7 +109,7 @@ impl KeyStore for UnhardenedKeyStore {
     }
 }
 
-impl DerivationStore for UnhardenedKeyStore {
+impl PuzzleStore for UnhardenedKeyStore {
     async fn puzzle_hash(&self, index: u32) -> Option<[u8; 32]> {
         sqlx::query!(
             "SELECT `p2_puzzle_hash` FROM `unhardened_keys` WHERE `index` = ?",

src/stores.rs

@@ -1,9 +1,7 @@
-mod coin_store;
-mod derivation_store;
 mod key_store;
+mod puzzle_store;
 mod transaction_store;
 
-pub use coin_store::*;
-pub use derivation_store::*;
 pub use key_store::*;
+pub use puzzle_store::*;
 pub use transaction_store::*;

src/stores/derivation_store.rs → src/stores/puzzle_store.rs

@@ -3,7 +3,7 @@ use std::future::Future;
 use crate::KeyStore;
 
 /// Keeps track of derived puzzle hashes in a wallet, based on its public keys.
-pub trait DerivationStore: KeyStore {
+pub trait PuzzleStore: KeyStore {
     /// Gets the derivation index of a puzzle hash.
     fn puzzle_hash_index(&self, puzzle_hash: [u8; 32]) -> impl Future<Output = Option<u32>> + Send;