lint and minor README, test.sh

yomarion · yomarion · commit 54798c5266dc · 2023-09-19T17:06:17.000+02:00
diff --git a/README.md b/README.md
@@ -24,14 +24,9 @@ Smart contracts on NEAR used by the
 Run all contracts unit tests like this:
 
 ```
-cd near-contracts/conversion_proxy
-cargo test
-cd near-contracts/fungible_conversion_proxy
-cargo test
-cd near-contracts/fungible_proxy
-cargo test
-cd near-contracts/mocks
-cargo test
+cargo test -p conversion_proxy
+cargo test -p fungible_conversion_proxy
+cargo test -p fungible_proxy
 ```
 
 ## Integration tests
diff --git a/conversion_proxy/src/lib.rs b/conversion_proxy/src/lib.rs
@@ -3,7 +3,8 @@ use near_sdk::json_types::{ValidAccountId, U128, U64};
 use near_sdk::serde::{Deserialize, Serialize};
 use near_sdk::serde_json::json;
 use near_sdk::{
-    env, log, near_bindgen, serde_json, AccountId, Balance, Gas, Promise, PromiseResult, Timestamp,
+    bs58, env, log, near_bindgen, serde_json, AccountId, Balance, Gas, Promise, PromiseResult,
+    Timestamp,
 };
 
 near_sdk::setup_alloc!();
@@ -19,7 +20,6 @@ const BASIC_GAS: Gas = 10_000_000_000_000;
  * Switchboard oracle-related declarations
  */
 
-
 #[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize)]
 pub struct SwitchboardDecimal {
     pub mantissa: i128,
@@ -36,7 +36,7 @@ pub struct PriceEntry {
 
 #[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize)]
 pub struct SwitchboarIx {
-    pub address: Vec<u8>,   // This feed address reference a specific price feed, see https://app.switchboard.xyz
+    pub address: Vec<u8>, // This feed address reference a specific price feed, see https://app.switchboard.xyz
     pub payer: Vec<u8>,
 }
 
@@ -46,7 +46,6 @@ trait Switchboard {
     fn aggregator_read(ix: SwitchboarIx) -> Promise<PriceEntry>;
 }
 
-
 ///
 /// This contract
 /// - feed_parser: should be a valid Switchboard feed parser
@@ -58,7 +57,7 @@ trait Switchboard {
 pub struct ConversionProxy {
     pub feed_parser: AccountId,
     pub feed_address: Vec<u8>,
-    pub feed_payer:Vec<u8>,
+    pub feed_payer: Vec<u8>,
     pub owner_id: AccountId,
 }
 
@@ -123,16 +122,24 @@ impl ConversionProxy {
             env::prepaid_gas(),
             MIN_GAS
         );
-        assert_eq!(currency, "USD", "Only payments denominated in USD are implemented for now");
+        assert_eq!(
+            currency, "USD",
+            "Only payments denominated in USD are implemented for now"
+        );
 
         let reference_vec: Vec<u8> = hex::decode(payment_reference.replace("0x", ""))
             .expect("Payment reference value error");
         assert_eq!(reference_vec.len(), 8, "Incorrect payment reference length");
 
-        let get_rate = sb_contract::aggregator_read(SwitchboarIx {address: self.feed_address.clone(), payer: self.feed_payer.clone()},
+        let get_rate = sb_contract::aggregator_read(
+            SwitchboarIx {
+                address: self.feed_address.clone(),
+                payer: self.feed_payer.clone(),
+            },
             &self.feed_parser,
             NO_DEPOSIT,
-            BASIC_GAS,);
+            BASIC_GAS,
+        );
         let callback_gas = BASIC_GAS * 3;
         let process_request_payment = ext_self::rate_callback(
             to,
@@ -178,20 +185,22 @@ impl ConversionProxy {
     pub fn set_feed_address(&mut self, feed_address: String) {
         let signer_id = env::predecessor_account_id();
         if self.owner_id == signer_id {
-            self.feed_address = bs58::decode(feed_address).into_vec().expect("Wrong feed address format");
+            self.feed_address = bs58::decode(feed_address)
+                .into_vec()
+                .expect("Wrong feed address format");
         } else {
             panic!("ERR_PERMISSION");
         }
     }
-    
+
     pub fn get_feed_address(&self) -> Vec<u8> {
         return self.feed_address.clone();
     }
 
     pub fn get_encoded_feed_address(&self) -> String {
         return bs58::encode(self.feed_address.clone()).into_string();
     }
-    
+
     pub fn set_owner(&mut self, owner: ValidAccountId) {
         let signer_id = env::predecessor_account_id();
         if self.owner_id == signer_id {
@@ -206,23 +215,35 @@ impl ConversionProxy {
         if self.owner_id == signer_id {
             let feed_payer = env::signer_account_pk();
             let vec_length = feed_payer.len();
-            println!("feed_payer: {}, len: {}", feed_payer.clone().into_iter().map(|c| c.to_string()).collect::<Vec<String>>().join(","), vec_length);
+            println!(
+                "feed_payer: {}, len: {}",
+                feed_payer
+                    .clone()
+                    .into_iter()
+                    .map(|c| c.to_string())
+                    .collect::<Vec<String>>()
+                    .join(","),
+                vec_length
+            );
             if vec_length == 32 {
                 self.feed_payer = env::signer_account_pk();
                 return;
             }
             // For some reason the VM prepends a 0 in front of the 32-long vector
             if vec_length > 32 {
-                log!("Trimming the feed_payer pk to fit length 32 from length {}", vec_length);
-                self.feed_payer = feed_payer[vec_length-32..].to_vec();
-                return
+                log!(
+                    "Trimming the feed_payer pk to fit length 32 from length {}",
+                    vec_length
+                );
+                self.feed_payer = feed_payer[vec_length - 32..].to_vec();
+                return;
             }
             panic!("ERR_OWNER_PK_LENGTH");
-         } else {
+        } else {
             panic!("ERR_PERMISSION");
         }
     }
-    
+
     pub fn get_feed_payer(&self) -> Vec<u8> {
         return self.feed_payer.clone();
     }
@@ -303,26 +324,34 @@ impl ConversionProxy {
             PromiseResult::Failed => panic!("ERR_FAILED_ORACLE_FETCH"),
         };
         // Check rate errors
-        assert!(rate.num_error == 0 && rate.num_success == 1, "Conversion errors: {}, successes: {}", rate.num_error, rate.num_success);
+        assert!(
+            rate.num_error == 0 && rate.num_success == 1,
+            "Conversion errors: {}, successes: {}",
+            rate.num_error,
+            rate.num_success
+        );
         // Check rate validity
         assert!(
             u64::from(max_rate_timespan) == 0
-                || rate.round_open_timestamp >= env::block_timestamp() - u64::from(max_rate_timespan),
+                || rate.round_open_timestamp
+                    >= env::block_timestamp() - u64::from(max_rate_timespan),
             "Conversion rate too old (Last updated: {})",
             rate.round_open_timestamp,
         );
-        let conversion_rate = 0_u128.checked_add_signed(rate.result.mantissa).expect("Negative conversion rate");
+        let conversion_rate = 0_u128
+            .checked_add_signed(rate.result.mantissa)
+            .expect("Negative conversion rate");
         let decimals = u32::from(rate.result.scale);
-        let main_payment =
-            (Balance::from(amount) * ONE_NEAR * 10u128.pow(decimals) / conversion_rate / ONE_FIAT) as u128;
+        let main_payment = (Balance::from(amount) * ONE_NEAR * 10u128.pow(decimals)
+            / conversion_rate
+            / ONE_FIAT) as u128;
         let fee_payment = Balance::from(fee_amount) * ONE_NEAR * 10u128.pow(decimals)
             / conversion_rate
             / ONE_FIAT;
 
         let total_payment = main_payment + fee_payment;
         // Check deposit
         if total_payment > env::attached_deposit() {
-            
             Promise::new(payer.clone().to_string()).transfer(env::attached_deposit());
             log!(
                 "Deposit too small for payment (Supplied: {}. Demand (incl. fees): {})",
@@ -387,7 +416,10 @@ mod tests {
         VMContext {
             current_account_id: predecessor_account_id.clone(),
             signer_account_id: predecessor_account_id.clone(),
-            signer_account_pk: vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31],
+            signer_account_pk: vec![
+                0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
+                23, 24, 25, 26, 27, 28, 29, 30, 31,
+            ],
             predecessor_account_id,
             input: vec![],
             block_index: 1,
diff --git a/mocks/src/fpo_oracle_mock.rs b/mocks/src/fpo_oracle_mock.rs
@@ -51,7 +51,6 @@ impl FPOContract {
 mod tests {
 
     use super::*;
-    // use crate::fpo_oracle_mock::AccountId;
     use near_sdk::{testing_env, Balance, Gas, MockedBlockchain, VMContext};
     use near_sdk_sim::to_yocto;
 
diff --git a/mocks/src/lib.rs b/mocks/src/lib.rs
@@ -1,3 +1,3 @@
 pub mod fpo_oracle_mock;
 pub mod fungible_token_mock;
-pub mod switchboard_feed_parser_mock;
+pub mod switchboard_feed_parser_mock;
diff --git a/mocks/src/switchboard_feed_parser_mock.rs b/mocks/src/switchboard_feed_parser_mock.rs
@@ -1,31 +1,30 @@
 use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
 use near_sdk::serde::{Deserialize, Serialize};
-use near_sdk::{Timestamp, env, near_bindgen, bs58};
+use near_sdk::{bs58, env, near_bindgen, Timestamp};
 
 /**
  * Mocking the Switchboard feed parser contract for tests
  */
 
+#[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize)]
+pub struct SwitchboardDecimal {
+    pub mantissa: i128,
+    pub scale: u32,
+}
 
- #[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize)]
- pub struct SwitchboardDecimal {
-     pub mantissa: i128,
-     pub scale: u32,
- }
- 
- #[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize)]
- pub struct PriceEntry {
-     pub result: SwitchboardDecimal,
-     pub num_success: u32,
-     pub num_error: u32,
-     pub round_open_timestamp: Timestamp,
- }
+#[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize)]
+pub struct PriceEntry {
+    pub result: SwitchboardDecimal,
+    pub num_success: u32,
+    pub num_error: u32,
+    pub round_open_timestamp: Timestamp,
+}
 
- #[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize)]
- pub struct SwitchboarIx {
-     pub address: Vec<u8>,
-     pub payer: Vec<u8>,
- }
+#[derive(BorshDeserialize, BorshSerialize, Serialize, Deserialize)]
+pub struct SwitchboarIx {
+    pub address: Vec<u8>,
+    pub payer: Vec<u8>,
+}
 
 // For mocks: state of Switchboard feed parser
 #[near_bindgen]
@@ -36,20 +35,20 @@ pub struct SwitchboardFeedParser {}
 impl SwitchboardFeedParser {
     #[allow(unused_variables)]
     pub fn aggregator_read(&self, ix: SwitchboarIx) -> Option<PriceEntry> {
-      match &*bs58::encode(ix.address).into_string() {
-        "testNEARtoUSD" => Some(PriceEntry {
-          result: SwitchboardDecimal {
-            mantissa: i128::from(1234000),
-            scale: u8::from(6).into()
-          },
-          num_success: 1,
-          num_error: 0,
-          round_open_timestamp: env::block_timestamp() -10,
-        }),
-        _ => {
-          panic!("InvalidAggregator")
-        },
-      }
+        match &*bs58::encode(ix.address).into_string() {
+            "testNEARtoUSD" => Some(PriceEntry {
+                result: SwitchboardDecimal {
+                    mantissa: i128::from(1234000),
+                    scale: u8::from(6).into(),
+                },
+                num_success: 1,
+                num_error: 0,
+                round_open_timestamp: env::block_timestamp() - 10,
+            }),
+            _ => {
+                panic!("InvalidAggregator")
+            }
+        }
     }
 }
 
@@ -58,7 +57,7 @@ mod tests {
 
     use super::*;
     // use crate::switchboard_feed_parser_mock::SwitchboardFeedParser;
-    use near_sdk::{testing_env, Balance, Gas, MockedBlockchain, VMContext, AccountId};
+    use near_sdk::{testing_env, AccountId, Balance, Gas, MockedBlockchain, VMContext};
     use near_sdk_sim::to_yocto;
 
     fn get_context(
@@ -88,32 +87,46 @@ mod tests {
     }
     #[test]
     fn aggregator_read() {
-      let disp_vec = bs58::decode("E81iAUr7RPDUksAFtZxn7curbUVRy1Gps6sr6JnQALHx").into_vec().expect("!!").into_iter().map(|c| c.to_string()).collect::<Vec<String>>().join(",");
+        let disp_vec = bs58::decode("E81iAUr7RPDUksAFtZxn7curbUVRy1Gps6sr6JnQALHx")
+            .into_vec()
+            .expect("!!")
+            .into_iter()
+            .map(|c| c.to_string())
+            .collect::<Vec<String>>()
+            .join(",");
         println!("RESULT: {}", disp_vec);
         let context = get_context("alice.near".to_string(), to_yocto("1"), 10u64.pow(14), true);
         testing_env!(context);
         let contract = SwitchboardFeedParser::default();
         if let Some(result) = contract.aggregator_read(SwitchboarIx {
-          address: bs58::decode("testNEARtoUSD").into_vec().expect("WRONG VEC"),
-          payer: bs58::decode("anynearpayer").into_vec().expect("WRONG VEC")
+            address: bs58::decode("testNEARtoUSD").into_vec().expect("WRONG VEC"),
+            payer: bs58::decode("anynearpayer").into_vec().expect("WRONG VEC"),
         }) {
-          assert_eq!(result.result.mantissa, i128::from(1234000));
-          assert_eq!(result.result.scale, 6);
+            assert_eq!(result.result.mantissa, i128::from(1234000));
+            assert_eq!(result.result.scale, 6);
         } else {
             panic!("NEAR/USD mock returned None")
         }
     }
     #[test]
     #[should_panic(expected = r#"InvalidAggregator"#)]
     fn missing_aggregator_read() {
-      let disp_vec = bs58::decode("E81iAUr7RPDUksAFtZxn7curbUVRy1Gps6sr6JnQALHx").into_vec().expect("!!").into_iter().map(|c| c.to_string()).collect::<Vec<String>>().join(",");
+        let disp_vec = bs58::decode("E81iAUr7RPDUksAFtZxn7curbUVRy1Gps6sr6JnQALHx")
+            .into_vec()
+            .expect("!!")
+            .into_iter()
+            .map(|c| c.to_string())
+            .collect::<Vec<String>>()
+            .join(",");
         println!("RESULT: {}", disp_vec);
         let context = get_context("alice.near".to_string(), to_yocto("1"), 10u64.pow(14), true);
         testing_env!(context);
         let contract = SwitchboardFeedParser::default();
         contract.aggregator_read(SwitchboarIx {
-          address: bs58::decode("wrongAggregator").into_vec().expect("WRONG VEC"),
-          payer: bs58::decode("anynearpayer").into_vec().expect("WRONG VEC")
+            address: bs58::decode("wrongAggregator")
+                .into_vec()
+                .expect("WRONG VEC"),
+            payer: bs58::decode("anynearpayer").into_vec().expect("WRONG VEC"),
         });
     }
 }
diff --git a/test.sh b/test.sh
@@ -1,4 +1,3 @@
-cd mocks/
+./mocks/build.sh
 ./build.sh
-cd ..
 cargo test --all
diff --git a/tests/sim/conversion_proxy.rs b/tests/sim/conversion_proxy.rs
diff --git a/tests/sim/utils.rs b/tests/sim/utils.rs
