added get_leaf route + tests

Author: simzzz

primitives/src/sentry.rs

@@ -722,6 +722,12 @@ pub struct ValidationErrorResponse {
     pub validation: Vec<String>,
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct GetLeafResponse {
+    pub merkle_proof: String,
+}
+
 /// Request body for posting new [`Event`]s to a [`Campaign`](crate::Campaign).
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 #[serde(rename_all = "camelCase")]

sentry/src/routes/channel.rs

@@ -18,16 +18,22 @@ use crate::{
     routes::{campaign::fetch_campaign_ids_for_channel, routers::RouteParams},
     Application, Auth,
 };
-use adapter::{client::Locked, Adapter, Dummy};
+use adapter::{
+    client::Locked,
+    util::{get_balance_leaf, get_signable_state_root},
+    Adapter, Dummy,
+};
 use axum::{extract::Path, Extension, Json};
 use futures::future::try_join_all;
 use hyper::{Body, Request, Response};
 use primitives::{
     balances::{Balances, CheckedState, UncheckedState},
+    merkle_tree::MerkleTree,
     sentry::{
         channel_list::{ChannelListQuery, ChannelListResponse},
-        AccountingResponse, AllSpendersQuery, AllSpendersResponse, ChannelPayRequest, LastApproved,
-        LastApprovedQuery, LastApprovedResponse, SpenderResponse, SuccessResponse,
+        AccountingResponse, AllSpendersQuery, AllSpendersResponse, ChannelPayRequest,
+        GetLeafResponse, LastApproved, LastApprovedQuery, LastApprovedResponse, SpenderResponse,
+        SuccessResponse,
     },
     spender::{Spendable, Spender},
     validator::NewState,
@@ -799,6 +805,106 @@ pub async fn channel_payout_axum<C: Locked + 'static>(
     Ok(Json(SuccessResponse { success: true }))
 }
 
+pub async fn get_spender_leaf<C: Locked + 'static>(
+    Extension(app): Extension<Arc<Application<C>>>,
+    Extension(channel_context): Extension<ChainOf<Channel>>,
+    Path(params): Path<(ChannelId, Address)>,
+) -> Result<Json<GetLeafResponse>, ResponseError> {
+    let channel = channel_context.context;
+
+    let approve_state = match latest_approve_state(&app.pool, &channel).await? {
+        Some(approve_state) => approve_state,
+        None => {
+            return Err(ResponseError::BadRequest(
+                "No ApproveState message for spender".to_string(),
+            ))
+        }
+    };
+
+    let state_root = approve_state.msg.state_root.clone();
+
+    let new_state = latest_new_state(&app.pool, &channel, &state_root)
+        .await?
+        .ok_or(ResponseError::BadRequest(
+            "No NewState message for spender".to_string(),
+        ))?;
+
+    let spender = params.1;
+    let amount = new_state
+        .msg
+        .balances
+        .spenders
+        .get(&spender)
+        .ok_or(ResponseError::BadRequest(
+            "No balance entry for spender!".to_string(),
+        ))?;
+    let element = get_balance_leaf(
+        true,
+        &spender,
+        &amount.to_precision(channel_context.token.precision.get()),
+    )
+    .map_err(|err| ResponseError::BadRequest(err.to_string()))?;
+
+    let merkle_tree =
+        MerkleTree::new(&[element]).map_err(|err| ResponseError::BadRequest(err.to_string()))?;
+
+    let signable_state_root = get_signable_state_root(&*channel.id(), &merkle_tree.root());
+
+    let res = hex::encode(signable_state_root);
+
+    Ok(Json(GetLeafResponse { merkle_proof: res }))
+}
+
+pub async fn get_earner_leaf<C: Locked + 'static>(
+    Extension(app): Extension<Arc<Application<C>>>,
+    Extension(channel_context): Extension<ChainOf<Channel>>,
+    Path(params): Path<(ChannelId, Address)>,
+) -> Result<Json<GetLeafResponse>, ResponseError> {
+    let channel = channel_context.context;
+
+    let approve_state = match latest_approve_state(&app.pool, &channel).await? {
+        Some(approve_state) => approve_state,
+        None => {
+            return Err(ResponseError::BadRequest(
+                "No ApproveState message for earner".to_string(),
+            ))
+        }
+    };
+
+    let state_root = approve_state.msg.state_root.clone();
+
+    let new_state = latest_new_state(&app.pool, &channel, &state_root)
+        .await?
+        .ok_or(ResponseError::BadRequest(
+            "No NewState message for earner".to_string(),
+        ))?;
+
+    let earner = params.1;
+    let amount = new_state
+        .msg
+        .balances
+        .earners
+        .get(&earner)
+        .ok_or(ResponseError::BadRequest(
+            "No balance entry for earner!".to_string(),
+        ))?;
+    let element = get_balance_leaf(
+        false,
+        &earner,
+        &amount.to_precision(channel_context.token.precision.get()),
+    )
+    .map_err(|err| ResponseError::BadRequest(err.to_string()))?;
+
+    let merkle_tree =
+        MerkleTree::new(&[element]).map_err(|err| ResponseError::BadRequest(err.to_string()))?;
+
+    let signable_state_root = get_signable_state_root(&*channel.id(), &merkle_tree.root());
+
+    let res = hex::encode(signable_state_root);
+
+    Ok(Json(GetLeafResponse { merkle_proof: res }))
+}
+
 /// POST `/v5/channel/0xXXX.../pay` request
 ///
 /// Body: [`ChannelPayRequest`]
@@ -1163,20 +1269,25 @@ pub mod validator_message {
 mod test {
     use super::*;
     use crate::{
-        db::{insert_campaign, insert_channel, CampaignRemaining},
+        db::{
+            insert_campaign, insert_channel, validator_message::insert_validator_message,
+            CampaignRemaining,
+        },
         test_util::setup_dummy_app,
     };
     use adapter::{
         ethereum::test_util::{GANACHE_INFO_1, GANACHE_INFO_1337},
         primitives::Deposit as AdapterDeposit,
     };
     use primitives::{
+        balances::UncheckedState,
         channel::Nonce,
         test_util::{
             ADVERTISER, CREATOR, DUMMY_CAMPAIGN, FOLLOWER, GUARDIAN, IDS, LEADER, LEADER_2,
             PUBLISHER, PUBLISHER_2,
         },
-        BigNum, ChainId, Deposit, UnifiedMap, ValidatorId,
+        validator::{ApproveState, MessageTypes, NewState},
+        BigNum, ChainId, Deposit, ToETHChecksum, UnifiedMap, ValidatorId,
     };
 
     #[tokio::test]
@@ -1897,4 +2008,119 @@ mod test {
             );
         }
     }
+
+    #[tokio::test]
+    async fn get_spender_and_earner_leafs() {
+        let mut balances: Balances<CheckedState> = Balances::new();
+        balances
+            .spend(*ADVERTISER, *PUBLISHER, UnifiedNum::from_u64(1000))
+            .expect("should spend");
+        balances
+            .spend(*ADVERTISER, *PUBLISHER_2, UnifiedNum::from_u64(1000))
+            .expect("should spend");
+        balances
+            .spend(*CREATOR, *PUBLISHER, UnifiedNum::from_u64(1000))
+            .expect("should spend");
+        balances
+            .spend(*CREATOR, *PUBLISHER_2, UnifiedNum::from_u64(1000))
+            .expect("should spend");
+
+        let app_guard = setup_dummy_app().await;
+        let app = Extension(Arc::new(app_guard.app.clone()));
+
+        let channel_context = Extension(
+            app.config
+                .find_chain_of(DUMMY_CAMPAIGN.channel.token)
+                .expect("Dummy channel Token should be present in config!")
+                .with(DUMMY_CAMPAIGN.channel),
+        );
+        let channel = channel_context.context;
+
+        insert_channel(&app.pool, &channel_context)
+            .await
+            .expect("should insert channel");
+
+        // Setting up the validator messages
+        let state_root = balances
+            .encode(channel.id(), channel_context.token.precision.get())
+            .expect("should encode");
+        let new_state: NewState<UncheckedState> = NewState {
+            state_root: state_root.clone(),
+            signature: IDS[&*LEADER].to_checksum(),
+            balances: balances.into_unchecked(),
+        };
+        let approve_state = ApproveState {
+            state_root,
+            signature: IDS[&*FOLLOWER].to_checksum(),
+            is_healthy: true,
+        };
+
+        insert_validator_message(
+            &app.pool,
+            &channel,
+            &channel.leader,
+            &MessageTypes::NewState(new_state),
+        )
+        .await
+        .expect("Should insert NewState msg");
+        insert_validator_message(
+            &app.pool,
+            &channel,
+            &channel.follower,
+            &MessageTypes::ApproveState(approve_state),
+        )
+        .await
+        .expect("Should insert NewState msg");
+
+        // generate proofs
+        let spender_proof = {
+            let element = get_balance_leaf(
+                true,
+                &*ADVERTISER,
+                &UnifiedNum::from_u64(2_000).to_precision(channel_context.token.precision.get()),
+            )
+            .expect("should get");
+
+            let merkle_tree = MerkleTree::new(&[element]).expect("Should build MerkleTree");
+
+            let signable_state_root = get_signable_state_root(&*channel.id(), &merkle_tree.root());
+
+            hex::encode(signable_state_root)
+        };
+
+        let earner_proof = {
+            let element = get_balance_leaf(
+                false,
+                &*PUBLISHER,
+                &UnifiedNum::from_u64(2_000).to_precision(channel_context.token.precision.get()),
+            )
+            .expect("should get balance leaf");
+
+            let merkle_tree = MerkleTree::new(&[element]).expect("Should build MerkleTree");
+
+            let signable_state_root = get_signable_state_root(&*channel.id(), &merkle_tree.root());
+
+            hex::encode(signable_state_root)
+        };
+
+        // call functions
+        let spender_leaf = get_spender_leaf(
+            app.clone(),
+            channel_context.clone(),
+            Path((channel.id(), *ADVERTISER)),
+        )
+        .await
+        .expect("should get spender leaf");
+        let earner_leaf = get_earner_leaf(
+            app.clone(),
+            channel_context.clone(),
+            Path((channel.id(), *PUBLISHER)),
+        )
+        .await
+        .expect("should get earner leaf");
+
+        // compare results
+        assert_eq!(spender_proof, spender_leaf.merkle_proof);
+        assert_eq!(earner_proof, earner_leaf.merkle_proof);
+    }
 }

sentry/src/routes/routers.rs

@@ -29,8 +29,8 @@ use crate::{
         channel::{
             add_spender_leaf, add_spender_leaf_axum, channel_dummy_deposit, channel_list,
             channel_payout, get_accounting_for_channel, get_accounting_for_channel_axum,
-            get_all_spender_limits, get_all_spender_limits_axum, get_spender_limits,
-            get_spender_limits_axum, last_approved, last_approved_axum,
+            get_all_spender_limits, get_all_spender_limits_axum, get_earner_leaf, get_spender_leaf,
+            get_spender_limits, get_spender_limits_axum, last_approved, last_approved_axum,
             validator_message::{
                 create_validator_messages, extract_params, list_validator_messages,
             },
@@ -146,6 +146,10 @@ pub fn channels_router_axum<C: Locked + 'static>() -> Router {
             ServiceBuilder::new().layer(middleware::from_fn(authentication_required::<C, _>)),
         );
 
+    let get_leaf_routes = Router::new()
+        .route("/spender/:addr", get(get_spender_leaf::<C>))
+        .route("/earner/:addr", get(get_earner_leaf::<C>));
+
     let channel_routes = Router::new()
         .route(
             "/pay",
@@ -155,6 +159,7 @@ pub fn channels_router_axum<C: Locked + 'static>() -> Router {
         .route("/accounting", get(get_accounting_for_channel_axum::<C>))
         .route("/last-approved", get(last_approved_axum::<C>))
         .nest("/spender", spender_routes)
+        .nest("/get-leaf", get_leaf_routes)
         .layer(
             // keeps the order from top to bottom!
             ServiceBuilder::new()