cleanup

Author: alexytsu

fil_token/src/token/mod.rs

@@ -9,7 +9,6 @@ use fvm_shared::bigint::bigint_ser::BigIntDe;
 use fvm_shared::bigint::BigInt;
 use fvm_shared::bigint::Zero;
 use fvm_shared::econ::TokenAmount;
-use fvm_shared::ActorID;
 
 use self::errors::ActorError;
 use self::state::TokenState;
@@ -83,15 +82,7 @@ where
     /// Injected blockstore
     bs: BS,
     /// Access to the runtime
-    fvm: FVM,
-}
-
-/// Resolve an address to an ActorID
-fn resolve_address(address: &Address) -> Result<ActorID> {
-    match fvm_sdk::actor::resolve_address(address) {
-        Some(addr) => Ok(addr),
-        None => Err(ActorError::AddrNotFound(*address)),
-    }
+    _fvm: FVM,
 }
 
 impl<BS, FVM> StandardToken<BS, FVM>
@@ -114,7 +105,7 @@ where
         init_state.save(&self.bs);
 
         let mint_params = params.mint_params;
-        self.mint(mint_params);
+        self.mint(mint_params)?;
         Ok(())
     }
 
@@ -157,21 +148,16 @@ where
         let balance = balances
             .delete(&holder)?
             .map(|de| de.1 .0)
-            .unwrap_or(TokenAmount::zero());
+            .unwrap_or_else(TokenAmount::zero);
         let new_balance = balance
             .checked_add(&params.value)
-            .ok_or(ActorError::Arithmetic(String::from(
-                "Minting into caused overflow",
-            )))?;
+            .ok_or_else(|| ActorError::Arithmetic(String::from("Minting into caused overflow")))?;
         balances.set(holder, BigIntDe(new_balance))?;
 
         // set the global supply of the contract
-        let new_supply = state
-            .supply
-            .checked_add(&params.value)
-            .ok_or(ActorError::Arithmetic(String::from(
-                "Minting caused total supply to overflow",
-            )))?;
+        let new_supply = state.supply.checked_add(&params.value).ok_or_else(|| {
+            ActorError::Arithmetic(String::from("Minting caused total supply to overflow"))
+        })?;
         state.supply = new_supply;
 
         // commit the state if supply and balance increased
@@ -230,7 +216,7 @@ where
             },
             // No allowance recorded previously
             None => {
-                caller_allowances_map.set(spender, BigIntDe(params.value.clone()));
+                caller_allowances_map.set(spender, BigIntDe(params.value.clone()))?;
                 params.value
             }
         };
@@ -263,7 +249,7 @@ where
                     .checked_sub(&params.value)
                     .unwrap() // Unwrap should be safe as allowance always > 0
                     .max(BigInt::zero());
-                caller_allowances_map.set(spender, BigIntDe(new_allowance.clone()));
+                caller_allowances_map.set(spender, BigIntDe(new_allowance.clone()))?;
                 new_allowance
             }
             None => {
@@ -298,7 +284,7 @@ where
         };
 
         let new_allowance = TokenAmount::zero();
-        caller_allowances_map.set(spender, BigIntDe(new_allowance.clone()));
+        caller_allowances_map.set(spender, BigIntDe(new_allowance.clone()))?;
         state.save(&self.bs);
 
         Ok(AllowanceReturn {
@@ -336,11 +322,11 @@ where
         })
     }
 
-    fn burn(&self, params: BurnParams) -> Result<BurnReturn> {
+    fn burn(&self, _params: BurnParams) -> Result<BurnReturn> {
         todo!()
     }
 
-    fn transfer_from(&self, params: TransferParams) -> Result<TransferReturn> {
+    fn transfer_from(&self, _params: TransferParams) -> Result<TransferReturn> {
         todo!()
     }
 }

fil_token/src/token/state.rs

@@ -1,6 +1,3 @@
-use std::ops::Add;
-use std::ops::Sub;
-
 use anyhow::anyhow;
 use cid::multihash::Code;
 use cid::Cid;
@@ -16,13 +13,10 @@ use fvm_sdk::sself;
 use fvm_shared::address::Address;
 use fvm_shared::bigint::bigint_ser;
 use fvm_shared::bigint::bigint_ser::BigIntDe;
-use fvm_shared::bigint::Zero;
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::ActorID;
 use fvm_shared::HAMT_BIT_WIDTH;
 
-use crate::blockstore::Blockstore;
-
 /// A macro to abort concisely.
 macro_rules! abort {
     ($code:ident, $msg:literal $(, $ex:expr)*) => {
@@ -96,7 +90,7 @@ impl TokenState {
             codec: DAG_CBOR,
             data: serialized,
         };
-        let cid = match bs.put(Code::Blake2b256.into(), &block) {
+        let cid = match bs.put(Code::Blake2b256, &block) {
             Ok(cid) => cid,
             Err(err) => abort!(USR_SERIALIZATION, "failed to store initial state: {:}", err),
         };
@@ -107,26 +101,24 @@ impl TokenState {
     }
 
     pub fn get_balance_map<BS: IpldStore + Copy>(&self, bs: &BS) -> Hamt<BS, BigIntDe, ActorID> {
-        let balances = match Hamt::<BS, BigIntDe, ActorID>::load(&self.balances, *bs) {
+        match Hamt::<BS, BigIntDe, ActorID>::load(&self.balances, *bs) {
             Ok(map) => map,
             Err(err) => abort!(USR_ILLEGAL_STATE, "Failed to load balances hamt: {:?}", err),
-        };
-        balances
+        }
     }
 
     /// Get the global allowances map
     ///
     /// Gets a HAMT with CIDs linking to other HAMTs
     pub fn get_allowances_map<BS: IpldStore + Copy>(&self, bs: &BS) -> Hamt<BS, Cid, ActorID> {
-        let allowances = match Hamt::<BS, Cid, ActorID>::load(&self.allowances, *bs) {
+        match Hamt::<BS, Cid, ActorID>::load(&self.allowances, *bs) {
             Ok(map) => map,
             Err(err) => abort!(
                 USR_ILLEGAL_STATE,
                 "Failed to load allowances hamt: {:?}",
                 err
             ),
-        };
-        allowances
+        }
     }
 
     /// Get the allowances map of a specific actor, lazily creating one if it didn't exist
@@ -259,8 +251,6 @@ pub struct TokenAmountDiff {
     pub actual: TokenAmount,
 }
 
-type TransferResult<T> = std::result::Result<T, TransferError>;
-
 pub enum TransferError {
     NoRecrHook,
     InsufficientAllowance(TokenAmountDiff),

fvm_dispatch/src/hash.rs

@@ -52,7 +52,7 @@ impl<T: Hasher> MethodHasher<T> {
 fn as_u32(bytes: &[u8]) -> u32 {
     ((bytes[0] as u32) << (8 * 3)) +
     ((bytes[1] as u32) << (8 * 2)) +
-    ((bytes[2] as u32) << (8 * 1)) +
+    ((bytes[2] as u32) << 8) +
     (bytes[3] as u32)
 }