node: Api server [WIP]

node/Cargo.toml

@@ -15,6 +15,7 @@ time = "^0.1"
 serde = { version = "1.0", features=["derive"] }
 hex = "^0.3"
 futures = "0.3"
+futures-util = "0.3"
 tokio = {version = "0.2", features=["full"]}
 warp = "0.2"
 tera = "1"

node/api.md

@@ -19,11 +19,11 @@
     * [/network/tx/:id](#networktxid)
 * [Wallet API](#wallet-api)
     * [/wallet/new](#walletnew)
-    * [/wallet/:id/balance](#walletidbalance)
-    * [/wallet/:id/txs](#walletidtxs)
-    * [/wallet/:id/address](#walletidaddress)
-    * [/wallet/:id/receiver](#walletidreceiver)
-    * [/wallet/:id/buildtx](#walletidbuildtx)
+    * [/wallet/balance](#walletbalance)
+    * [/wallet/txs](#wallettxs)
+    * [/wallet/address](#walletaddress)
+    * [/wallet/receiver](#walletreceiver)
+    * [/wallet/buildtx](#walletbuildtx)
 
 
 Responses are listed in JSON for a time being, but we are also going to provide the API responses via XDR format.
@@ -312,7 +312,7 @@ forming transactions and tracking the state of unspent outputs.
 
 ### /wallet/new
 
-Creates a new wallet
+Creates a new wallet. Successful submission returns 200 OK status.
 
 Request:
 
@@ -325,21 +325,13 @@ struct NewWalletRequest {
 }
 ```
 
-Response:
-
-```rust
-struct NewWalletResponse {
-    id: [u8; 32],
-}
-```
-
-### /wallet/:id/balance
+### /wallet/balance
 
 Returns wallet's balance.
 
 Request:
 
-`GET /wallet/:id/balance`
+`GET /wallet/balance`
 
 Response:
 
@@ -350,13 +342,13 @@ struct Balance {
 ```
 
 
-### /wallet/:id/txs
+### /wallet/txs
 
 Lists annotated transactions.
 
 Request:
 
-`GET /wallet/:id/txs?cursor=[5786...]`
+`GET /wallet/txs?cursor=[5786...]`
 
 Response:
 
@@ -367,13 +359,13 @@ struct WalletTxs {
 }
 ```
 
-### /wallet/:id/address
+### /wallet/address
 
 Generates a new address.
 
 Request:
 
-`GET /wallet/:id/address`
+`GET /wallet/address`
 
 Response:
 
@@ -383,13 +375,13 @@ struct NewAddress {
 }
 ```
 
-### /wallet/:id/receiver
+### /wallet/receiver
 
 Generates a new receiver.
 
 Request:
 
-`POST /wallet/:id/receiver`
+`POST /wallet/receiver`
 
 ```rust
 struct NewReceiverRequest {
@@ -407,13 +399,13 @@ struct NewReceiverResponse {
 }
 ```
 
-### /wallet/:id/buildtx
+### /wallet/buildtx
 
 Builds a transaction and returns the signing instructions.
 
 Request:
 
-`POST /wallet/:id/buildtx`
+`POST /wallet/buildtx`
 
 ```rust
 struct BuildTxRequest {

node/src/api.rs

@@ -1,24 +1,39 @@
+mod network;
+mod response;
+pub(self) mod serde_utils;
+mod types;
+mod wallet;
+mod warp_utils;
+
 use std::net::SocketAddr;
 use warp::Filter;
 
 use crate::bc::BlockchainRef;
 use crate::config::Config;
 use crate::wallet_manager::WalletRef;
+use std::convert::Infallible;
 
 /// Launches the API server.
 pub async fn launch(config: Config, bc: BlockchainRef, wallet: WalletRef) {
     let conf = &config.data.api;
     if conf.disabled {
         return;
     }
-    let echo =
-        warp::path!("v1" / "echo" / String).map(|thingy| format!("API v1 echo: {}!", thingy));
+    let routes = routes(bc, wallet);
+
+    eprintln!("API: http://{}", &conf.listen);
+    warp::serve(routes).run(conf.listen).await;
+}
+
+fn routes(
+    bc: BlockchainRef,
+    wallet: WalletRef,
+) -> impl Filter<Extract = impl warp::Reply, Error = Infallible> + Clone {
+    let wallet_routes = wallet::routes(wallet);
+    let network_routes = network::routes(bc);
 
     let not_found = warp::any()
         .map(|| warp::reply::with_status("Not found.", warp::http::StatusCode::NOT_FOUND));
 
-    let routes = echo.or(not_found);
-
-    eprintln!("API: http://{}", &conf.listen);
-    warp::serve(routes).run(conf.listen).await;
+    wallet_routes.or(network_routes).or(not_found)
 }

node/src/api/network.rs

@@ -0,0 +1,56 @@
+mod handlers;
+mod requests;
+mod responses;
+
+use crate::api::types::{Cursor, HexId};
+use crate::api::warp_utils::{handle1, handle2};
+use crate::bc::BlockchainRef;
+use std::convert::Infallible;
+use warp::Filter;
+
+pub fn routes(
+    bc: BlockchainRef,
+) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
+    use warp::*;
+
+    let status = path!("v1" / "network" / "status")
+        .and(get())
+        .and(with_bc(bc.clone()))
+        .and_then(handle1(handlers::status));
+
+    let mempool = path!("v1" / "network" / "mempool")
+        .and(get())
+        .and(query::<Cursor>())
+        .and(with_bc(bc.clone()))
+        .and_then(handle2(handlers::mempool));
+
+    let blocks = path!("v1" / "network" / "blocks")
+        .and(get())
+        .and(query::<Cursor>())
+        .and(with_bc(bc.clone()))
+        .and_then(handle2(handlers::blocks));
+
+    let block = path!("v1" / "network" / "block" / HexId)
+        .and(get())
+        .and(with_bc(bc.clone()))
+        .and_then(handle2(handlers::block));
+
+    let tx = path!("v1" / "network" / "tx" / HexId)
+        .and(get())
+        .and(with_bc(bc.clone()))
+        .and_then(handle2(handlers::tx));
+
+    let submit = path!("v1" / "network" / "submit")
+        .and(post())
+        .and(body::json())
+        .and(with_bc(bc.clone()))
+        .and_then(handle2(handlers::submit));
+
+    status.or(mempool).or(blocks).or(block).or(tx).or(submit)
+}
+
+fn with_bc(
+    bc: BlockchainRef,
+) -> impl Filter<Extract = (BlockchainRef,), Error = Infallible> + Clone {
+    warp::any().map(move || bc.clone())
+}

node/src/api/network/handlers.rs

@@ -0,0 +1,141 @@
+use crate::{
+    api::{
+        network::{requests, responses},
+        response::{error, ResponseResult},
+        types,
+        types::{Cursor, HexId},
+    },
+    bc::BlockchainRef,
+};
+use blockchain::{BlockHeader, BlockchainState, Mempool};
+use std::convert::TryFrom;
+use zkvm::Tx;
+
+pub(super) async fn status(bc: BlockchainRef) -> ResponseResult<responses::Status> {
+    let bc_state = BlockchainState::make_initial(5, vec![]).0;
+    let mempool = &Mempool::new(bc_state.clone(), 5);
+
+    let status = mempool_status(mempool);
+    let state = &bc_state;
+    let tip = state.tip.clone().into();
+    let utreexo = [None; 64];
+
+    let state = types::State { tip, utreexo };
+
+    let peers = vec![];
+
+    Ok(responses::Status {
+        mempool: status,
+        state,
+        peers,
+    })
+}
+
+pub(super) async fn mempool(
+    cursor: types::Cursor,
+    bc: BlockchainRef,
+) -> ResponseResult<responses::MempoolTxs> {
+    let bc_state = BlockchainState::make_initial(5, vec![]).0;
+    let mempool = &Mempool::new(bc_state.clone(), 5);
+    let txs_owned = Vec::<blockchain::BlockTx>::new();
+    let txs = txs_owned.iter();
+
+    let offset = cursor
+        .cursor
+        .parse::<usize>()
+        .map_err(|_| error::invalid_cursor())?;
+    let elements = cursor.count() as usize;
+
+    let status = mempool_status(mempool);
+    let txs = txs
+        .skip(offset)
+        .take(elements)
+        .map(|tx| types::Tx::try_from(tx.clone()))
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|_| error::tx_compute_error())?;
+
+    Ok(responses::MempoolTxs {
+        cursor: (offset + elements).to_string(),
+        status,
+        txs,
+    })
+}
+
+pub(super) async fn blocks(cursor: Cursor, bc: BlockchainRef) -> ResponseResult<responses::Blocks> {
+    let blocks_headers = Vec::<BlockHeader>::new();
+
+    let offset = cursor
+        .cursor
+        .parse::<usize>()
+        .map_err(|_| error::invalid_cursor())?;
+    let count = cursor.count() as usize;
+
+    let headers = blocks_headers
+        .iter()
+        .skip(offset)
+        .take(count)
+        .map(|b| b.clone().into())
+        .collect::<Vec<_>>();
+    Ok(responses::Blocks {
+        cursor: (offset + count).to_string(),
+        blocks: headers,
+    })
+}
+
+pub(super) async fn block(block_id: HexId, bc: BlockchainRef) -> ResponseResult<responses::Block> {
+    let header = BlockHeader::make_initial(0, zkvm::Hash::default());
+    let txs = Vec::<blockchain::BlockTx>::new();
+
+    Ok(responses::Block {
+        header: header.into(),
+        txs,
+    })
+}
+
+pub(super) async fn tx(tx_id: HexId, bc: BlockchainRef) -> ResponseResult<responses::TxResponse> {
+    let block_tx = blockchain::BlockTx {
+        tx: Tx {
+            header: zkvm::TxHeader {
+                version: 0,
+                mintime_ms: 0,
+                maxtime_ms: 0,
+            },
+            program: vec![],
+            signature: musig::Signature {
+                s: Default::default(),
+                R: Default::default(),
+            },
+            proof: zkvm::bulletproofs::r1cs::R1CSProof::from_bytes(&[0; 1 + 15 * 32]).unwrap(),
+        },
+        proofs: vec![],
+    };
+
+    let tx = types::Tx::try_from(block_tx).map_err(|_| error::tx_compute_error())?;
+
+    let status = responses::TxStatus {
+        confirmed: true,
+        block_height: 0,
+        block_id: [0; 32],
+    };
+
+    Ok(responses::TxResponse { status, tx })
+}
+
+pub(super) async fn submit(
+    raw_tx: requests::RawTx,
+    bc: BlockchainRef,
+) -> ResponseResult<responses::Submit> {
+    unimplemented!()
+}
+
+fn mempool_status(mempool: &Mempool) -> types::MempoolStatus {
+    let count = mempool.entries().count() as u64;
+    let size = mempool.len() as u64;
+    let feerate = 0;
+
+    types::MempoolStatus {
+        count,
+        size,
+        feerate,
+    }
+}

node/src/api/network/requests.rs

@@ -0,0 +1,14 @@
+use serde::Deserialize;
+
+use crate::api::serde_utils::BigArray;
+use crate::api::types::TxHeader;
+
+#[derive(Deserialize)]
+pub struct RawTx {
+    pub header: TxHeader,
+    pub program: Vec<u8>,
+    #[serde(with = "BigArray")]
+    pub signature: [u8; 64],
+    pub r1cs_proof: Vec<u8>,
+    pub utreexo_proofs: Vec<Vec<u8>>,
+}