Fix test 32 find 004

address/dev.json

@@ -1,12 +1,12 @@
 {
-    "permissionManager": "CBUIECO5NXZOL5POGHLLXJA3MXBSZVPOCPEEZK6YPH35FHXXGGRZEPY3",
-    "redemption": "CBGCPYBFKKV55BUV4KFEHVGEDDUSGCOP64M6UMXN5L4BQ7COOULPFIO4",
+    "permissionManager": "CDHCGBGXRIJKEBMDTWZLX5BHQUYZOQFGZGVMU2Y62MKRP5Y5IRQDHA3X",
+    "redemption": "CCSB5EN2WZH7YSE6ARFF7H3GX55KEAVK6C446MRRICKRR3FSH6IPEEOH",
     "tokens": {
-        "EUR_SPKCC": "CDVABO2TG6KJS74P6LIPPWFRA5HPBGO37CXUHGTHTCED44NLXJSNSFU4",
-        "EUR_USTBL": "CCUK56RAXVS747P2CQ45LUIPC2LR5V6HNMEVSRPRGSJPGMT7HXA7BBRM",
-        "EUTBL": "CAKWQAE674WRL5IRBFJ647QO6TQGU2GSIRJHSUTGSSWE3KQKZDB3F3KV",
-        "SPKCC": "CAHG7OFUTEALOXPHFYWSDMRYAEQBWWIPRFCNER3OPIDSIISGZCX2QFKQ",
-        "UKTBL": "CD2SDO6TMSVIJSJKAJDA72K37VP3YT5Q4MG3FZZD6F5OLIUYTME2T6HW",
-        "USTBL": "CDSEVER7V7JHIFZQIBV4TO4RFMS7UVW7FVDUVRBSDV75RQBPT6Z5DHI2"
+        "EUR_SPKCC": "CCESW4HBXTKCI2P7FM4PKZMFE3UCAR3I3RGJ5IAOLEYPL4ZYDBOPQ4CL",
+        "EUR_USTBL": "CDF4XHGLAQSXJPBATZESNRANJNCOI5UPF3LNKP6GR4I43CLMS3ZFXRKZ",
+        "EUTBL": "CDF5ZQMLKA6XO6BSXTPZOUZXHXT6XG56K2XASZIGGBXF2ACWBO5HW2JF",
+        "SPKCC": "CAIXJTAK4NPEBAI66SAJF7I2CDJNGM2Q32XQXY6VJNIKAPEED55EH65U",
+        "UKTBL": "CBKJFQ33FH6ANWM7NNI4WYJRICZZWGKBJMHAJQ7INPJDUYJ345SGN3VX",
+        "USTBL": "CALN5FSRP6H3A66MSLJS7SKDNPPH3CGQSU7VXNHI5CQ2ZM55RZNTQLUS"
     }
 }

contracts/token/src/contract.rs

@@ -96,6 +96,7 @@ impl Token {
     pub fn mint(e: &Env, account: Address, amount: i128, caller: Address) {
         Self::auth_mint(e, caller);
         Self::assert_has_role(e, &account, &WHITELISTED_ROLE);
+        assert!(amount > 0, "Invalid zero-amount mint");
         Base::mint(e, &account, amount);
     }
 
@@ -109,10 +110,13 @@ impl Token {
         Self::auth_mint(e, caller);
         Self::assert_idempotency_key_not_used(e, &idempotency_key);
 
+        assert!(operations.len() > 0, "Empty batch");
+
         for operation in &operations {
             let account = operation.0;
             Self::assert_has_role(e, &account, &WHITELISTED_ROLE);
             let amount = operation.1;
+            assert!(amount > 0, "Invalid zero-amount mint");
             Base::mint(e, &account, amount);
         }
         Self::consume_idempotency_key(e, &idempotency_key);
@@ -131,6 +135,7 @@ impl Token {
     #[when_not_paused]
     pub fn burn(e: &Env, account: Address, amount: i128, caller: Address) {
         Self::auth_burn(e, caller);
+        assert!(amount > 0, "Invalid zero-amount burn");
         Self::burn_no_auth(e, account, amount);
     }
 
@@ -143,9 +148,12 @@ impl Token {
     ) {
         Self::auth_burn(e, caller);
         Self::assert_idempotency_key_not_used(e, &idempotency_key);
+        assert!(operations.len() > 0, "Empty batch");
+
         for operation in &operations {
             let account = operation.0;
             let amount = operation.1;
+            assert!(amount > 0, "Invalid zero-amount burn");
             Self::burn_no_auth(e, account, amount);
         }
         Self::consume_idempotency_key(e, &idempotency_key);
@@ -179,6 +187,7 @@ impl Token {
     pub fn transfer(e: &Env, from: Address, to: Address, amount: i128) {
         Self::assert_has_role(e, &from, &WHITELISTED_ROLE);
         Self::assert_has_role(e, &to, &WHITELISTED_ROLE);
+        assert!(amount > 0, "Invalid zero-amount transfer");
         Base::transfer(e, &from, &to, amount);
     }
 
@@ -193,6 +202,7 @@ impl Token {
         Self::assert_has_role(e, &from, &WHITELISTED_ROLE);
         Self::assert_has_role(e, &to, &WHITELISTED_ROLE);
         Self::assert_idempotency_key_not_used(e, &idempotency_key);
+        assert!(amount > 0, "Invalid zero-amount transfer");
         Base::transfer(e, &from, &to, amount);
         Self::consume_idempotency_key(e, &idempotency_key);
     }

contracts/token/src/test.rs

@@ -138,6 +138,24 @@ fn test_mint_should_emit_a_mint_event() {
     assert_eq!(event.2.to_xdr(&e), amount.to_xdr(&e));
 }
 
+#[test]
+fn test_mint_should_fail_if_amount_is_not_strictly_positive() {
+    let e = setup_env();
+    let minter: Address = Address::generate(&e);
+    let user: Address = Address::generate(&e);
+    let amount: i128 = 0;
+    let (_, _, client) = deploy_token(&e);
+    let (admin, permission_manager_address, permission_manager_client) =
+        deploy_permission_manager(&e);
+    client.set_permission_manager(&permission_manager_address);
+    permission_manager_client.grant_role(&admin, &minter, &MINTER_ROLE);
+    permission_manager_client.grant_role(&admin, &user, &WHITELISTED_ROLE);
+
+    let result = client.try_mint(&user, &amount, &minter);
+
+    assert!(result.is_err());
+}
+
 #[test]
 fn test_mint_should_require_auth_and_mint_and_emit_a_mint_event() {
     let e = setup_env();
@@ -271,6 +289,50 @@ fn test_mint_batch_should_require_auth_and_mint_and_emit_mint_events() {
     assert_eq!(balance2, amount2);
 }
 
+#[test]
+fn test_mint_batch_should_fail_if_operations_is_empty() {
+    let e = setup_env();
+    let minter: Address = Address::generate(&e);
+    let user1: Address = Address::generate(&e);
+    let user2: Address = Address::generate(&e);
+    let idempotency_key: String = String::from_str(&e, "IDEMPOTENCY_KEY");
+    let (_, _, client) = deploy_token(&e);
+    let (admin, permission_manager_address, permission_manager_client) =
+        deploy_permission_manager(&e);
+    client.set_permission_manager(&permission_manager_address);
+    permission_manager_client.grant_role(&admin, &minter, &MINTER_ROLE);
+    permission_manager_client.grant_role(&admin, &user1, &WHITELISTED_ROLE);
+    permission_manager_client.grant_role(&admin, &user2, &WHITELISTED_ROLE);
+    let operations = Vec::new(&e);
+
+    let result = client.try_mint_batch(&operations, &minter, &idempotency_key);
+
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_mint_batch_should_fail_if_one_of_the_operations_is_not_strictly_positive() {
+    let e = setup_env();
+    let minter: Address = Address::generate(&e);
+    let user1: Address = Address::generate(&e);
+    let user2: Address = Address::generate(&e);
+    let idempotency_key: String = String::from_str(&e, "IDEMPOTENCY_KEY");
+    let (_, _, client) = deploy_token(&e);
+    let (admin, permission_manager_address, permission_manager_client) =
+        deploy_permission_manager(&e);
+    client.set_permission_manager(&permission_manager_address);
+    permission_manager_client.grant_role(&admin, &minter, &MINTER_ROLE);
+    permission_manager_client.grant_role(&admin, &user1, &WHITELISTED_ROLE);
+    permission_manager_client.grant_role(&admin, &user2, &WHITELISTED_ROLE);
+    let mut operations = Vec::new(&e);
+    operations.push_front(MintBatchOperation(user1.clone(), 0));
+    operations.push_front(MintBatchOperation(user2.clone(), 2000000));
+
+    let result = client.try_mint_batch(&operations, &minter, &idempotency_key);
+
+    assert!(result.is_err());
+}
+
 #[test]
 fn test_mint_batch_should_fail_if_minter_is_not_minter() {
     let e = setup_env();
@@ -442,7 +504,7 @@ fn test_redeem_should_fail_if_amount_is_not_positive() {
     permission_manager_client.grant_role(&admin, &minter, &MINTER_ROLE);
     permission_manager_client.grant_role(&admin, &user, &WHITELISTED_ROLE);
     permission_manager_client.grant_role(&admin, &redemption_address, &WHITELISTED_ROLE);
-    client.mint(&user, &amount, &minter);
+    client.mint(&user, &100, &minter);
 
     let result = client.try_redeem(&amount, &user, &redeem_idempotency_key);
 
@@ -548,7 +610,7 @@ fn test_redeem_should_fail_if_idempotency_key_is_already_used() {
     assert!(result.is_err());
 }
 
-//// transfer
+//// safe_transfer
 
 #[test]
 fn test_safe_transfer_should_transfer_tokens_and_emit_a_transfer_event() {
@@ -606,6 +668,28 @@ fn test_safe_transfer_should_transfer_tokens_and_emit_a_transfer_event() {
     assert_eq!(balance2, amount);
 }
 
+#[test]
+fn test_safe_transfer_should_fail_if_amount_is_not_strictly_positive() {
+    let e = setup_env();
+    let amount: i128 = 1000000;
+    let user1: Address = Address::generate(&e);
+    let user2: Address = Address::generate(&e);
+    let minter: Address = Address::generate(&e);
+    let transfer_idempotency_key: String = String::from_str(&e, "IDEMPOTENCY_KEY2");
+    let (_, _, client) = deploy_token(&e);
+    let (admin, permission_manager_address, permission_manager_client) =
+        deploy_permission_manager(&e);
+    client.set_permission_manager(&permission_manager_address);
+    permission_manager_client.grant_role(&admin, &minter, &MINTER_ROLE);
+    permission_manager_client.grant_role(&admin, &user1, &WHITELISTED_ROLE);
+    permission_manager_client.grant_role(&admin, &user2, &WHITELISTED_ROLE);
+    client.mint(&user1, &amount, &minter);
+
+    let result = client.try_safe_transfer(&user1, &user2, &0, &transfer_idempotency_key);
+
+    assert!(result.is_err());
+}
+
 #[test]
 fn test_safe_transfer_should_fail_if_user1_is_not_whitelisted() {
     let e = setup_env();
@@ -746,6 +830,27 @@ fn test_burn_should_require_auth_and_burn_and_emit_a_burn_event() {
     assert_eq!(balance, 0);
 }
 
+#[test]
+fn test_burn_should_fail_if_amount_is_not_strictly_positive() {
+    let e = setup_env();
+    let amount: i128 = 1000000;
+    let minter: Address = Address::generate(&e);
+    let burner: Address = Address::generate(&e);
+    let (_, _, client) = deploy_token(&e);
+    let (_, redemption_address, _) = deploy_redemption(&e);
+    let (admin, permission_manager_address, permission_manager_client) =
+        deploy_permission_manager(&e);
+    client.set_permission_manager(&permission_manager_address);
+    permission_manager_client.grant_role(&admin, &minter, &MINTER_ROLE);
+    permission_manager_client.grant_role(&admin, &redemption_address, &WHITELISTED_ROLE);
+    permission_manager_client.grant_role(&admin, &burner, &BURNER_ROLE);
+    client.mint(&redemption_address, &amount, &minter);
+
+    let result = client.try_burn(&redemption_address, &0, &burner);
+
+    assert!(result.is_err());
+}
+
 #[test]
 fn test_burn_should_fail_if_not_burner() {
     let e = setup_env();
@@ -833,6 +938,54 @@ fn test_burn_batch_should_require_auth_and_burn_and_emit_a_burn_events() {
     assert_eq!(balance, 0);
 }
 
+#[test]
+fn test_burn_batch_should_fail_if_operations_is_empty() {
+    let e = setup_env();
+    let amount: i128 = 1000000;
+    let minter: Address = Address::generate(&e);
+    let burner: Address = Address::generate(&e);
+    let burn_idempotency_key: String = String::from_str(&e, "IDEMPOTENCY_KEY");
+    let (_, _, client) = deploy_token(&e);
+    let (_, redemption_address, _) = deploy_redemption(&e);
+    let (admin, permission_manager_address, permission_manager_client) =
+        deploy_permission_manager(&e);
+    client.set_permission_manager(&permission_manager_address);
+    permission_manager_client.grant_role(&admin, &minter, &MINTER_ROLE);
+    permission_manager_client.grant_role(&admin, &redemption_address, &WHITELISTED_ROLE);
+    permission_manager_client.grant_role(&admin, &burner, &BURNER_ROLE);
+    client.mint(&redemption_address, &amount, &minter);
+    let operations = Vec::new(&e);
+
+    let result = client.try_burn_batch(&operations, &burner, &burn_idempotency_key);
+
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_burn_batch_should_fail_if_one_of_the_operations_is_not_strictly_positive() {
+    let e = setup_env();
+    let amount: i128 = 1000000;
+    let minter: Address = Address::generate(&e);
+    let burner: Address = Address::generate(&e);
+    let burn_idempotency_key: String = String::from_str(&e, "IDEMPOTENCY_KEY");
+    let (_, _, client) = deploy_token(&e);
+    let (_, redemption_address, _) = deploy_redemption(&e);
+    let (admin, permission_manager_address, permission_manager_client) =
+        deploy_permission_manager(&e);
+    client.set_permission_manager(&permission_manager_address);
+    permission_manager_client.grant_role(&admin, &minter, &MINTER_ROLE);
+    permission_manager_client.grant_role(&admin, &redemption_address, &WHITELISTED_ROLE);
+    permission_manager_client.grant_role(&admin, &burner, &BURNER_ROLE);
+    client.mint(&redemption_address, &amount, &minter);
+    let mut operations = Vec::new(&e);
+    operations.push_front(BurnBatchOperation(redemption_address.clone(), 0));
+    operations.push_front(BurnBatchOperation(redemption_address.clone(), amount / 2));
+
+    let result = client.try_burn_batch(&operations, &burner, &burn_idempotency_key);
+
+    assert!(result.is_err());
+}
+
 #[test]
 fn test_burn_batch_should_fail_if_not_burner() {
     let e = setup_env();