Mdjakovic/update point

CHANGELOG.md

@@ -32,6 +32,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - ref: Rename Set Amount Splitter to Fixed Amount Splitter [(#754)](https://github.com/andromedaprotocol/andromeda-core/pull/754)
 - Point ADO: remove Rates module from the contract[(#761)](https://github.com/andromedaprotocol/andromeda-core/pull/761)
 - feat: SignedDecimal for Distance [(#774)](https://github.com/andromedaprotocol/andromeda-core/pull/774)
+- feat: SignedDecimal for Point [(#779)](https://github.com/andromedaprotocol/andromeda-core/pull/779)
 
 ### Fixed
 

contracts/math/andromeda-graph/src/contract.rs

@@ -309,8 +309,6 @@ pub fn execute_store_user_coordinate(
                 let user: AndrAddr = user_res.owner;
                 let user_addr = user.get_raw_address(&ctx.deps.as_ref())?;
 
-                user_point_coordinate.validate()?;
-
                 USER_COORDINATE.save(ctx.deps.storage, user_addr, &user_point_coordinate)?;
             } else {
                 return Err(ContractError::InvalidADOType {
@@ -412,9 +410,9 @@ pub fn get_user_coordinate(deps: Deps, user: AndrAddr) -> Result<CoordinateInfo,
     let user_coordinate = USER_COORDINATE.load(deps.storage, user_addr)?;
 
     Ok(CoordinateInfo {
-        x: user_coordinate.x_coordinate,
-        y: user_coordinate.y_coordinate,
-        z: user_coordinate.z_coordinate,
+        x: user_coordinate.x_coordinate.to_string(),
+        y: user_coordinate.y_coordinate.to_string(),
+        z: user_coordinate.z_coordinate.map(|z| z.to_string()),
     })
 }
 

contracts/math/andromeda-graph/src/testing/mock_querier.rs

@@ -9,8 +9,8 @@ use cosmwasm_std::QuerierWrapper;
 use cosmwasm_std::{
     from_json,
     testing::{mock_env, mock_info, MockApi, MockQuerier, MockStorage, MOCK_CONTRACT_ADDR},
-    Coin, ContractInfoResponse, OwnedDeps, Querier, QuerierResult, QueryRequest, SystemError,
-    SystemResult, WasmQuery,
+    Coin, ContractInfoResponse, OwnedDeps, Querier, QuerierResult, QueryRequest, SignedDecimal,
+    SystemError, SystemResult, WasmQuery,
 };
 use cosmwasm_std::{to_json_binary, Binary, ContractResult};
 
@@ -91,9 +91,9 @@ impl WasmMockQuerier {
         match from_json(msg).unwrap() {
             PointQueryMsg::GetPoint {} => {
                 let msg_response = PointCoordinate {
-                    x_coordinate: "10".to_string(),
-                    y_coordinate: "10".to_string(),
-                    z_coordinate: Some("10".to_string()),
+                    x_coordinate: SignedDecimal::percent(1000),
+                    y_coordinate: SignedDecimal::percent(1000),
+                    z_coordinate: Some(SignedDecimal::percent(1000)),
                 };
                 SystemResult::Ok(ContractResult::Ok(to_json_binary(&msg_response).unwrap()))
             }

contracts/math/andromeda-point/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "andromeda-point"
-version = "0.1.0"
+version = "0.1.0-a.1"
 authors = ["Mitar Djakovic <[email protected]>"]
 edition = "2021"
 rust-version = "1.75.0"

contracts/math/andromeda-point/src/execute.rs

@@ -57,8 +57,6 @@ pub fn set_point(ctx: ExecuteContext, point: PointCoordinate) -> Result<Response
         ContractError::Unauthorized {}
     );
 
-    point.validate()?;
-
     DATA.save(ctx.deps.storage, &point.clone())?;
     DATA_OWNER.save(ctx.deps.storage, &sender)?;
 

contracts/math/andromeda-point/src/testing/tests.rs

@@ -1,6 +1,6 @@
 use crate::contract::query;
 use andromeda_math::point::{GetDataOwnerResponse, PointCoordinate, PointRestriction, QueryMsg};
-use cosmwasm_std::{from_json, testing::mock_env};
+use cosmwasm_std::{from_json, testing::mock_env, SignedDecimal};
 
 use andromeda_std::{amp::AndrAddr, error::ContractError};
 
@@ -14,83 +14,40 @@ fn test_instantiation() {
 #[test]
 fn test_set_and_update_point() {
     let (mut deps, info) = proper_initialization(PointRestriction::Private);
-    let point = PointCoordinate::from_f64(10_f64, 10_f64, Some(10_f64));
-    point.validate().unwrap();
+    let point = PointCoordinate {
+        x_coordinate: SignedDecimal::from_ratio(10, 1),
+        y_coordinate: SignedDecimal::from_ratio(10, 1),
+        z_coordinate: Some(SignedDecimal::from_ratio(10, 1)),
+    };
+
     set_point(deps.as_mut(), &point, info.sender.as_ref()).unwrap();
 
     let query_res: PointCoordinate = query_point(deps.as_ref()).unwrap();
 
     assert_eq!(point, query_res);
 
-    let point = PointCoordinate::from_f64(5_f64, 5_f64, Some(5_f64));
-    point.validate().unwrap();
+    let point = PointCoordinate {
+        x_coordinate: SignedDecimal::from_ratio(5, 1),
+        y_coordinate: SignedDecimal::from_ratio(5, 1),
+        z_coordinate: Some(SignedDecimal::from_ratio(5, 1)),
+    };
+
     set_point(deps.as_mut(), &point, info.sender.as_ref()).unwrap();
 
     let query_res: PointCoordinate = query_point(deps.as_ref()).unwrap();
 
     assert_eq!(point, query_res);
 }
 
-struct TestHandlePointCoordinate {
-    name: &'static str,
-    point_coordinate: PointCoordinate,
-    expected_error: Option<ContractError>,
-}
-
-#[test]
-fn test_set_point_invalid() {
-    let test_cases = vec![
-        TestHandlePointCoordinate {
-            name: "Invalid x_coordinate",
-            point_coordinate: PointCoordinate {
-                x_coordinate: "10.abc".to_string(),
-                y_coordinate: "10".to_string(),
-                z_coordinate: Some("10".to_string()),
-            },
-            expected_error: Some(ContractError::ParsingError {
-                err: "x_coordinate: can not parse to f64".to_string(),
-            }),
-        },
-        TestHandlePointCoordinate {
-            name: "Invalid y_coordinate",
-            point_coordinate: PointCoordinate {
-                x_coordinate: "10".to_string(),
-                y_coordinate: "10.abc".to_string(),
-                z_coordinate: None,
-            },
-            expected_error: Some(ContractError::ParsingError {
-                err: "y_coordinate: can not parse to f64".to_string(),
-            }),
-        },
-        TestHandlePointCoordinate {
-            name: "Invalid z_coordinate",
-            point_coordinate: PointCoordinate {
-                x_coordinate: "10".to_string(),
-                y_coordinate: "10".to_string(),
-                z_coordinate: Some("10.abc".to_string()),
-            },
-            expected_error: Some(ContractError::ParsingError {
-                err: "z_coordinate: can not parse to f64".to_string(),
-            }),
-        },
-    ];
-
-    for test in test_cases {
-        let res = test.point_coordinate.validate();
-
-        if let Some(err) = test.expected_error {
-            assert_eq!(res.unwrap_err(), err, "{}", test.name);
-            continue;
-        }
-
-        assert!(res.is_ok())
-    }
-}
-
 #[test]
 fn test_delete_point() {
     let (mut deps, info) = proper_initialization(PointRestriction::Private);
-    let point = PointCoordinate::from_f64(10_f64, 10_f64, Some(10_f64));
+    let point = PointCoordinate {
+        x_coordinate: SignedDecimal::from_ratio(10, 1),
+        y_coordinate: SignedDecimal::from_ratio(10, 1),
+        z_coordinate: Some(SignedDecimal::from_ratio(10, 1)),
+    };
+
     set_point(deps.as_mut(), &point, info.sender.as_ref()).unwrap();
     delete_point(deps.as_mut(), info.sender.as_ref()).unwrap();
     query_point(deps.as_ref()).unwrap_err();
@@ -100,7 +57,11 @@ fn test_delete_point() {
 fn test_restriction_private() {
     let (mut deps, info) = proper_initialization(PointRestriction::Private);
 
-    let point = PointCoordinate::from_f64(10_f64, 10_f64, Some(10_f64));
+    let point = PointCoordinate {
+        x_coordinate: SignedDecimal::from_ratio(10, 1),
+        y_coordinate: SignedDecimal::from_ratio(10, 1),
+        z_coordinate: Some(SignedDecimal::from_ratio(10, 1)),
+    };
     let external_user = "external".to_string();
 
     // Set Point as owner
@@ -125,7 +86,11 @@ fn test_restriction_private() {
 fn test_restriction_public() {
     let (mut deps, info) = proper_initialization(PointRestriction::Public);
 
-    let point = PointCoordinate::from_f64(10_f64, 10_f64, Some(10_f64));
+    let point = PointCoordinate {
+        x_coordinate: SignedDecimal::from_ratio(10, 1),
+        y_coordinate: SignedDecimal::from_ratio(10, 1),
+        z_coordinate: Some(SignedDecimal::from_ratio(10, 1)),
+    };
     let external_user = "external".to_string();
 
     // Set Point as owner
@@ -152,8 +117,16 @@ fn test_restriction_public() {
 fn test_restriction_restricted() {
     let (mut deps, info) = proper_initialization(PointRestriction::Restricted);
 
-    let point = PointCoordinate::from_f64(10_f64, 10_f64, Some(10_f64));
-    let point2 = PointCoordinate::from_f64(5_f64, 5_f64, Some(5_f64));
+    let point = PointCoordinate {
+        x_coordinate: SignedDecimal::from_ratio(10, 1),
+        y_coordinate: SignedDecimal::from_ratio(10, 1),
+        z_coordinate: Some(SignedDecimal::from_ratio(10, 1)),
+    };
+    let point2 = PointCoordinate {
+        x_coordinate: SignedDecimal::from_ratio(5, 1),
+        y_coordinate: SignedDecimal::from_ratio(5, 1),
+        z_coordinate: Some(SignedDecimal::from_ratio(5, 1)),
+    };
     let external_user = "external".to_string();
     let external_user2 = "external2".to_string();
 
@@ -198,7 +171,11 @@ fn test_query_data_owner() {
     let (mut deps, _) = proper_initialization(PointRestriction::Restricted);
     let external_user = "external".to_string();
     let external_user2 = "external2".to_string();
-    let point = PointCoordinate::from_f64(10_f64, 10_f64, Some(10_f64));
+    let point = PointCoordinate {
+        x_coordinate: SignedDecimal::from_ratio(10, 1),
+        y_coordinate: SignedDecimal::from_ratio(10, 1),
+        z_coordinate: Some(SignedDecimal::from_ratio(10, 1)),
+    };
     set_point(deps.as_mut(), &point, &external_user.clone()).unwrap();
 
     let res: GetDataOwnerResponse =

packages/andromeda-math/src/point.rs

@@ -1,5 +1,6 @@
-use andromeda_std::{amp::AndrAddr, andr_exec, andr_instantiate, andr_query, error::ContractError};
+use andromeda_std::{amp::AndrAddr, andr_exec, andr_instantiate, andr_query};
 use cosmwasm_schema::{cw_serde, QueryResponses};
+use cosmwasm_std::SignedDecimal;
 
 #[andr_instantiate]
 #[cw_serde]
@@ -24,49 +25,9 @@ pub enum PointRestriction {
 
 #[cw_serde]
 pub struct PointCoordinate {
-    pub x_coordinate: String,
-    pub y_coordinate: String,
-    pub z_coordinate: Option<String>,
-}
-
-impl PointCoordinate {
-    pub fn from_f64(x_coordinate: f64, y_coordinate: f64, z_coordinate: Option<f64>) -> Self {
-        let z_coordinate: Option<String> = z_coordinate.map(|z| z.to_string());
-
-        Self {
-            x_coordinate: x_coordinate.to_string(),
-            y_coordinate: y_coordinate.to_string(),
-            z_coordinate,
-        }
-    }
-    pub fn validate(&self) -> Result<(), ContractError> {
-        let x_coordinate = self.x_coordinate.parse::<f64>();
-        if x_coordinate.is_err() {
-            return Err(ContractError::ParsingError {
-                err: "x_coordinate: can not parse to f64".to_string(),
-            });
-        }
-
-        let y_coordinate = self.y_coordinate.parse::<f64>();
-        if y_coordinate.is_err() {
-            return Err(ContractError::ParsingError {
-                err: "y_coordinate: can not parse to f64".to_string(),
-            });
-        }
-
-        match &self.z_coordinate {
-            None => (),
-            Some(z) => {
-                let z_coordinate = z.parse::<f64>();
-                if z_coordinate.is_err() {
-                    return Err(ContractError::ParsingError {
-                        err: "z_coordinate: can not parse to f64".to_string(),
-                    });
-                }
-            }
-        }
-        Ok(())
-    }
+    pub x_coordinate: SignedDecimal,
+    pub y_coordinate: SignedDecimal,
+    pub z_coordinate: Option<SignedDecimal>,
 }
 
 #[andr_query]
@@ -83,69 +44,3 @@ pub enum QueryMsg {
 pub struct GetDataOwnerResponse {
     pub owner: AndrAddr,
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_validate_point_coordinate_valid() {
-        let point = PointCoordinate {
-            x_coordinate: "10".to_string(),
-            y_coordinate: "10".to_string(),
-            z_coordinate: Some("10".to_string()),
-        };
-        let res = point.validate();
-        assert!(res.is_ok());
-
-        let point = PointCoordinate {
-            x_coordinate: "10".to_string(),
-            y_coordinate: "10".to_string(),
-            z_coordinate: None,
-        };
-        let res = point.validate();
-        assert!(res.is_ok());
-    }
-
-    #[test]
-    fn test_validate_point_coordinate_invalid() {
-        let point = PointCoordinate {
-            x_coordinate: "10.abc".to_string(),
-            y_coordinate: "10".to_string(),
-            z_coordinate: Some("10".to_string()),
-        };
-        let res = point.validate().unwrap_err();
-        assert_eq!(
-            res,
-            ContractError::ParsingError {
-                err: "x_coordinate: can not parse to f64".to_string()
-            }
-        );
-
-        let point = PointCoordinate {
-            x_coordinate: "10".to_string(),
-            y_coordinate: "10.abc".to_string(),
-            z_coordinate: Some("10".to_string()),
-        };
-        let res = point.validate().unwrap_err();
-        assert_eq!(
-            res,
-            ContractError::ParsingError {
-                err: "y_coordinate: can not parse to f64".to_string()
-            }
-        );
-
-        let point = PointCoordinate {
-            x_coordinate: "10".to_string(),
-            y_coordinate: "10".to_string(),
-            z_coordinate: Some("10.xyz".to_string()),
-        };
-        let res = point.validate().unwrap_err();
-        assert_eq!(
-            res,
-            ContractError::ParsingError {
-                err: "z_coordinate: can not parse to f64".to_string()
-            }
-        );
-    }
-}