fix: circle ci lint

contracts/cw1155-base/src/execute.rs

@@ -213,15 +213,15 @@ where
             info,
         } = env;
 
-        let from = &if let Some(from) = from {
+        let from = if let Some(from) = from {
             deps.api.addr_validate(&from)?
         } else {
             info.sender.clone()
         };
         let to = deps.api.addr_validate(&to)?;
 
         let balance_update =
-            self.verify_approval(deps.storage, &env, &info, from, &token_id, amount)?;
+            self.verify_approval(deps.storage, &env, &info, &from, &token_id, amount)?;
 
         let mut rsp = Response::default();
 
@@ -267,14 +267,14 @@ where
             info,
         } = env;
 
-        let from = &if let Some(from) = from {
+        let from = if let Some(from) = from {
             deps.api.addr_validate(&from)?
         } else {
             info.sender.clone()
         };
         let to = deps.api.addr_validate(&to)?;
 
-        let batch = self.verify_approvals(deps.storage, &env, &info, from, batch)?;
+        let batch = self.verify_approvals(deps.storage, &env, &info, &from, batch)?;
 
         let mut rsp = Response::default();
         let event = self.update_balances(
@@ -314,25 +314,25 @@ where
             env,
         } = env;
 
-        let from = &if let Some(from) = from {
+        let from = if let Some(from) = from {
             deps.api.addr_validate(&from)?
         } else {
             info.sender.clone()
         };
 
         // whoever can transfer these tokens can burn
         let balance_update =
-            self.verify_approval(deps.storage, &env, &info, from, &token_id, amount)?;
+            self.verify_approval(deps.storage, &env, &info, &from, &token_id, amount)?;
 
         let mut rsp = Response::default();
 
         let event = self.update_balances(
             &mut deps,
             &env,
-            Some(from.clone()),
+            Some(from),
             None,
             vec![TokenAmount {
-                token_id: token_id.to_string(),
+                token_id,
                 amount: balance_update.amount,
             }],
         )?;
@@ -353,16 +353,16 @@ where
             env,
         } = env;
 
-        let from = &if let Some(from) = from {
+        let from = if let Some(from) = from {
             deps.api.addr_validate(&from)?
         } else {
             info.sender.clone()
         };
 
-        let batch = self.verify_approvals(deps.storage, &env, &info, from, batch)?;
+        let batch = self.verify_approvals(deps.storage, &env, &info, &from, batch)?;
 
         let mut rsp = Response::default();
-        let event = self.update_balances(&mut deps, &env, Some(from.clone()), None, batch)?;
+        let event = self.update_balances(&mut deps, &env, Some(from), None, batch)?;
         rsp = rsp.add_event(event);
 
         Ok(rsp)
@@ -549,17 +549,17 @@ where
                 // remove token approvals
                 for (operator, approval) in self
                     .token_approves
-                    .prefix((&token_id, from))
+                    .prefix((token_id, from))
                     .range(deps.storage, None, None, Order::Ascending)
                     .collect::<StdResult<Vec<_>>>()?
                 {
                     if approval.is_expired(env) || approval.amount <= *amount {
                         self.token_approves
-                            .remove(deps.storage, (&token_id, &from, &operator));
+                            .remove(deps.storage, (token_id, from, &operator));
                     } else {
                         self.token_approves.update(
                             deps.storage,
-                            (&token_id, &from, &operator),
+                            (token_id, from, &operator),
                             |prev| -> StdResult<_> {
                                 let mut new_approval = prev.unwrap();
                                 new_approval.amount = new_approval.amount.checked_sub(*amount)?;
@@ -671,7 +671,7 @@ where
     ) -> Option<TokenApproval> {
         match self
             .token_approves
-            .load(storage, (&token_id, owner, operator))
+            .load(storage, (token_id, owner, operator))
         {
             Ok(approval) => {
                 if !approval.is_expired(env) {

contracts/cw1155-base/src/state.rs

@@ -1,6 +1,6 @@
-use schemars::JsonSchema;
+use cosmwasm_schema::cw_serde;
 use serde::de::DeserializeOwned;
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 use std::marker::PhantomData;
 
 use cosmwasm_std::{Addr, CustomMsg, StdError, StdResult, Storage, Uint128};
@@ -128,7 +128,7 @@ where
     }
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[cw_serde]
 pub struct TokenInfo<T> {
     /// Metadata JSON Schema
     pub token_uri: Option<String>,

packages/cw1155/src/msg.rs

@@ -1,12 +1,10 @@
 use cosmwasm_schema::cw_serde;
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter};
 
 use cosmwasm_std::{Binary, Env, Uint128};
 use cw_utils::Expiration;
 
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[cw_serde]
 pub struct Cw1155InstantiateMsg {
     /// Name of the token contract
     pub name: String,
@@ -23,8 +21,7 @@ pub struct Cw1155InstantiateMsg {
 /// This is like Cw1155ExecuteMsg but we add a Mint command for a minter
 /// to make this stand-alone. You will likely want to remove mint and
 /// use other control logic in any contract that inherits this.
-#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
-#[serde(rename_all = "snake_case")]
+#[cw_serde]
 pub enum Cw1155ExecuteMsg<T> {
     // cw1155
     /// BatchSendFrom is a base message to move multiple types of tokens in batch,
@@ -101,7 +98,7 @@ pub enum Cw1155ExecuteMsg<T> {
     },
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[cw_serde]
 pub struct Cw1155MintMsg<T> {
     pub token_id: String,
     /// The amount of the newly minted tokens

packages/cw1155/src/query.rs

@@ -1,6 +1,5 @@
 use cosmwasm_schema::{cw_serde, QueryResponses};
 use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
 
 use cosmwasm_std::{Addr, Uint128};
 use cw_ownable::cw_ownable_query;
@@ -93,47 +92,47 @@ pub enum Cw1155QueryMsg<Q: JsonSchema> {
     Extension { msg: Q },
 }
 
-#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
+#[cw_serde]
 pub struct BalanceResponse {
     pub balance: Uint128,
 }
 
-#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
+#[cw_serde]
 pub struct AllBalancesResponse {
     pub balances: Vec<Balance>,
 }
 
-#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
+#[cw_serde]
 pub struct Balance {
     pub token_id: String,
     pub owner: Addr,
     pub amount: Uint128,
 }
 
-#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
+#[cw_serde]
 pub struct BatchBalanceResponse {
     pub balances: Vec<Uint128>,
 }
 
-#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
+#[cw_serde]
 pub struct NumTokensResponse {
     pub count: Uint128,
 }
 
-#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
+#[cw_serde]
 pub struct Approval {
     /// Account that can transfer/send the token
     pub spender: String,
     /// When the Approval expires (maybe Expiration::never)
     pub expires: Expiration,
 }
 
-#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
+#[cw_serde]
 pub struct ApprovedForAllResponse {
     pub operators: Vec<Approval>,
 }
 
-#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
+#[cw_serde]
 pub struct IsApprovedForAllResponse {
     pub approved: bool,
 }
@@ -144,15 +143,15 @@ pub struct AllTokenInfoResponse<T> {
     pub info: TokenInfoResponse<T>,
 }
 
-#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
+#[cw_serde]
 pub struct TokenInfoResponse<T> {
     /// Should be a url point to a json file
     pub token_uri: Option<String>,
     /// You can add any custom metadata here when you extend cw1155-base
     pub extension: T,
 }
 
-#[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
+#[cw_serde]
 pub struct TokensResponse {
     /// Contains all token_ids in lexicographical ordering
     /// If there are more than `limit`, use `start_from` in future queries

packages/cw1155/src/receiver.rs

@@ -1,12 +1,9 @@
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-
 use crate::TokenAmount;
+use cosmwasm_schema::cw_serde;
 use cosmwasm_std::{to_json_binary, Binary, CosmosMsg, StdResult, Uint128, WasmMsg};
 
 /// Cw1155ReceiveMsg should be de/serialized under `Receive()` variant in a ExecuteMsg
-#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, JsonSchema, Debug)]
-#[serde(rename_all = "snake_case")]
+#[cw_serde]
 pub struct Cw1155ReceiveMsg {
     /// The account that executed the send message
     pub operator: String,
@@ -37,8 +34,7 @@ impl Cw1155ReceiveMsg {
 }
 
 /// Cw1155BatchReceiveMsg should be de/serialized under `BatchReceive()` variant in a ExecuteMsg
-#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, JsonSchema, Debug)]
-#[serde(rename_all = "snake_case")]
+#[cw_serde]
 pub struct Cw1155BatchReceiveMsg {
     pub operator: String,
     pub from: Option<String>,
@@ -66,8 +62,7 @@ impl Cw1155BatchReceiveMsg {
 }
 
 // This is just a helper to properly serialize the above message
-#[derive(Serialize, Deserialize, Clone, PartialEq, Eq, JsonSchema, Debug)]
-#[serde(rename_all = "snake_case")]
+#[cw_serde]
 enum ReceiverExecuteMsg {
     Receive(Cw1155ReceiveMsg),
     BatchReceive(Cw1155BatchReceiveMsg),