wip tx building code

Author: ross-weir

chaincash_app/src/lib.rs

@@ -1,4 +1,4 @@
-use chaincash_offchain::{node::node_from_config, TransactionBuilder};
+use chaincash_offchain::{node::node_from_config, TransactionService};
 use chaincash_server::{Server, ServerState};
 use chaincash_store::{ChainCashStore, Update};
 use config::{Environment, File};
@@ -64,12 +64,12 @@ impl ChainCashApp {
             });
 
         let node = node_from_config(&self.config.node);
-        let tx_builder = TransactionBuilder::new(node.clone());
+        let tx_service = TransactionService::new(node.clone());
 
         let state = ServerState {
             store,
             node,
-            tx_builder,
+            tx_service,
         };
 
         Ok(Server::serve(listener, state).await?)

chaincash_offchain/src/lib.rs

@@ -2,5 +2,6 @@ pub mod contracts;
 pub mod node;
 pub mod transactions;
 
+pub use ergo_node_interface::NanoErg;
 pub use node::NodeInterface;
-pub use transactions::TransactionBuilder;
+pub use transactions::TransactionService;

chaincash_offchain/src/transactions.rs

@@ -1,21 +1,54 @@
 pub mod reserves;
 
-use ergo_lib::ergo_chain_types::EcPoint;
+use crate::NanoErg;
+use ergo_lib::{ergo_chain_types::EcPoint, wallet::tx_builder::SUGGESTED_TX_FEE};
 use ergo_node_interface::NodeInterface;
 
 #[derive(Clone)]
-pub struct TransactionBuilder {
+pub struct TransactionService {
     // TODO: inputs cache so we dont need to fetch after each tx build
     node: NodeInterface,
+    fee: NanoErg,
 }
 
-impl TransactionBuilder {
+struct TxContext {
+    current_height: u64,
+    change_address: String,
+    fee: NanoErg,
+}
+
+impl TransactionService {
     pub fn new(node: NodeInterface) -> Self {
-        Self { node }
+        Self::with_fee(node, SUGGESTED_TX_FEE().as_u64().clone())
+    }
+
+    pub fn with_fee(node: NodeInterface, fee: NanoErg) -> Self {
+        Self { node, fee }
+    }
+
+    // TODO: handle request failures
+    // handle wallet uninitialized/locked
+    // handle no change address
+    fn get_ctx(&self) -> TxContext {
+        let wallet_status = self.node.wallet_status().unwrap();
+
+        TxContext {
+            current_height: self.node.current_block_height().unwrap(),
+            change_address: wallet_status.change_address.unwrap(),
+            fee: self.fee,
+        }
     }
 
-    pub fn create_reserve(pk: EcPoint, amount: u64) {
-        // fetch inputs (and cache?)
-        todo!()
+    pub fn create_reserve(&self, pk: EcPoint, amount: NanoErg) {
+        // TODO: get utxos from a cache
+        let ctx = self.get_ctx();
+        let inputs = self
+            .node
+            .unspent_boxes_with_min_total(amount + ctx.fee)
+            .unwrap();
+        // transform inputs into box_selector
+        // build reserve output ErgoboxCandidate
+        // still want to use a separate function to actually build the tx so we can decouple from
+        // node usage and make the building testable
     }
 }

chaincash_server/src/app.rs

@@ -1,14 +1,14 @@
 //! ChainCash payment server creation and serving.
 use axum::{routing::get, Router};
-use chaincash_offchain::{NodeInterface, TransactionBuilder};
+use chaincash_offchain::{NodeInterface, TransactionService};
 use chaincash_store::ChainCashStore;
 use tracing::info;
 
 #[derive(Clone)]
 pub struct ServerState {
     pub store: ChainCashStore,
     pub node: NodeInterface,
-    pub tx_builder: TransactionBuilder,
+    pub tx_service: TransactionService,
 }
 
 pub struct Server;
@@ -35,26 +35,30 @@ impl Server {
 }
 
 #[cfg(test)]
-mod tests {
-    use hyper::{Body, Request, StatusCode};
-    use tower::ServiceExt;
-
-    use super::*;
-
-    fn make_state() -> ServerState {
-        let node = NodeInterface::new("", "", "").unwrap();
+impl ServerState {
+    pub fn for_test() -> Self {
+        // node shouldn't be actually used in unit tests
+        let node = NodeInterface::new("hello", "127.0.0.1", "9032").unwrap();
 
         ServerState {
             store: ChainCashStore::open_in_memory().unwrap(),
             node: node.clone(),
-            tx_builder: TransactionBuilder::new(node),
+            tx_service: TransactionService::new(node),
         }
     }
+}
+
+#[cfg(test)]
+mod tests {
+    use hyper::{Body, Request, StatusCode};
+    use tower::ServiceExt;
+
+    use super::*;
 
     #[tokio::test]
     async fn test_healthcheck() {
         let response = Server::router()
-            .with_state(make_state())
+            .with_state(ServerState::for_test())
             .oneshot(Request::get("/healthcheck").body(Body::default()).unwrap())
             .await
             .unwrap();